Java 面向对象

Java*面向对象*

所有事物以类的形式存在，使用也是以类的形式使用
Java是面向对象的语言

1、面向过程编程：

	1、打开冰箱门方法
	2、把大象装进冰箱的方法
	3、关闭冰箱门
	在main方法中依次调用该3方法
	
面向过程，是一种自顶向下的编程
主要体现功能
（被动的）

2、面向对象编程：

	冰箱对象：
		1、打开冰箱门
		2、关闭冰箱门
	大象对象：
		1、走进冰箱方法
	在main方法中:
		1、先创建两个对象
		
面向对象，是将事物高度抽象化，面向对象必须先建立抽象模型，之后直接使用模型就行了；
主要体现类
（自发的）

3、面向对象的优点：

耦合性：代码与代码之间的关联
  	1、解耦
 	2、每个对象之间以类的形式存在，使用的时候就方便很多

4、类的概念：

由一类事物根据属性和行为，抽取出来的模板（一类事物相同特征的集合）

类：单继承

5、对象的概念

根据类创建出的个体

6、创建类：

在一个.java文件中，只能有一个使用public修饰的类

访问修饰符(public /默认的) class 类名{
 		类体：
 			属性：变量(全局变量)
 			行为：方法
 }

7、使用类：

1、声明类的变量
	类名 引用(地址,全类名@16进制的hash值);
	全类名：类的全称(包名.类名)
2、赋值
  new 类名();//创建一个该类的对象
3、给类中的成员变量赋值：
  变量名.属性名 = 赋值

8、垃圾回收器（GC）：

垃圾：在堆中没有任何引用指向的对象
垃圾回收器：
	专门回收没有任何引用指向的对象，伴随着程序执行而执行

	在程序执行过程中，Java自动的执行一段垃圾回收程序，检测堆中，有无没有任何引用指向的对象，如果有则回收
	在对象回收之前，垃圾回收器会调用一个finalize方法，提醒该对象被回收
	
垃圾回收即时性：
	当垃圾回收程序获取到cpu时间了之后才会去扫描回收
加快垃圾回收器执行：System.gc();
通过重写类的finalize方法可以查看到对象被回收的过程

9、退出程序执行

System.exit(0);

10、get/set方法

private String name;
set：给成员变量赋值（有参数无返回值）
    public void setName(String name){
    	this.name = name;
	}
get：获取成员变量的值（有返回值无参数）
    public String getName(){
    	return name;
	}

11、构造方法：

调用：创建对象时调用
使用new关键字时调用
要求：
	1、方法名与类名相同
	2、没有返回值类型，连void都不要
作用：
	给成员变量赋值
构造方法特点：
	如果不写构造方法，编译器会自动给一个无参数构造
	在类中添加构造方法后，编译器就不会给无参构造
	构造方法也可以重载
	
    无参构造方法默认调用：super();//父类

12、方法的重载：

概念：
	在一个类中，方法名相同，参数列表不一样的一系列方法称为方法的重载
    代码中带有()都是调用方法
    创建类时给该类添加至少两个构造方法(无参数的构造，全部参数的构造)
    
    方法的重载与返回值类型无关，与访问修饰符也无关
    只与方法名和参数列表有关

13、this关键字：

1、作用：
    用于区分成员变量和局部变量
    用于调用方法
调用构造方法：
	在构造方法内部调用构造方法：
	this();（必须在第一行）
	用构造方法时必须在构造方法的第一行
	在构造方法中不能互相调用
调用普通方法：
	this.方法名();
	在普通方法中允许互相调用，需要避免！！！

14、参数传递：

引用传递：
	传递的是地址值
值传递：
	基本类型之间传递参数，传递的是具体值

Java*面向对象三大特征*

 1、封装
 2、继承
 3、多态

1、封装

行为公开化，属性私有化
	1）、方法的封装（一段特有功能的代码段）
		工具方法（方法功能已确定，直接通过类名访问得到）
		工具方法：例：
			Math.random();//生成随机小数
			System.toString;//将数组转为字符串进行返回
			System.exit(0);//关闭程序
			System.currentTimeMillis();
			System.nanoTime();

2、继承：

所有类直接或者间接继承自Object（对象）

一类东西有共性，在共性中找寻个性
语法：
	public/默认的 class 类名  extends 类名{
  	
  }
优点:
	代码复用
 	为父类做扩展
 	方便统一管理

继承使用注意事项：

1、在子类构造方法的第一行需要调用父类的构造方法
2、构造方法不能继承，只能间接调用
3、私有的东西不能继承

/*
继承时：
    B类（子类）的无参构造方法,默认调用A类（父类）的无参构造方法(super();)
    A类（父类）默认调用Object类... (super();)
*/    

public static void main(String[] args){
    B b = new B();
    System.out.println(b.a);
    //输出三个值：10、20、20
}

class A{
    int a;
    public A(){
        a = 10;
        System.out.println(a);
    }
}
class B extends A{
    int a = 20;
    public B(){
        System.out.println(a);
    }
}

3、多态

super关键字

1、用于区分父类的成员变量和局部变量
2、调用方法
  	调用构造方法：
  	在子类构造方法的第一行上添加super();
3、调用普通方法：
  	super.方法名()/this.方法名()

包：

作用：用于管理类
包的声明：
    包的命名规则与变量命名规则相似
    包名所有字母小写

访问修饰符：

1、public：在整个工程中均可以使用
2、protected：同包及其不同包的子类中可以访问	
3、默认的：修饰的东西可以在同包中访问，出了包之后就不能访问了
4、private：修饰的东西只能在声明该东西的类中使用
	访问修饰符     整个工程      不同包的子类     同包类     本类
	public   		OK      	OK       	 OK   	   OK
	protected 		NO     		OK       	 OK   	   OK
	默认的           NO      	  NO		   OK   	 OK
	private  		No	    	NO		  	 NO   	   OK        
装数据时：
    1、属性私有化 （需为其提供访问该属性的 公有的get和set方法，才能被间接访问）
    2、行为公开化

方法的重写：

因为父类的行为满足不了子类的需求，可以重新编写该行为
方法重写的规则：
    两同两小一大原则：
    1、两同：
        1）、方法名相同(方法的签名(方法名和参数列表))
        2）、参数列表相同
    2、两小：
        1）、非基本类型： 返回值类型可以小于等于父类（基本类型或void时：返回值类型必须相同）
    	2）、抛出的异常可以小于等于父类
    3、访问修饰符大于等于父类

异常：

异常的父类Exception
非检查异常 RuntimeException
检查异常

向上造型：

为了对子类对象进行统一的管理

子类的对象赋值给父类的引用
父类的引用指向子类的对象
    引用能够调用哪些内容取决于父类
    调用的具体内容看子类的对象

this和super关键字

*this**关键字：*

*1.**区分成员变量和局部变量*

*2.**调用构造方法this()*

*调用普通方法this.方法名()*

*super**关键字：*

*1.**用于区分父类的成员变量与局部变量（this关键字也行）*

*2.**调用构造方法的时候，编辑器会自动在构造方法的第一行添加super()*

*调用普通方法 super.方法名*

Override与Overload的区别

方法的重载：
方法名相同，参数列表不同
方法的重写：
子类覆盖父类的方法
两同：方法名相同，参数列表相同
两小：子类方法的返回值类型和抛出异常的类型小于等于父类方法的返回值类型和抛出异常类型，基本数据类型的返回值相同。
一大：子类方法的权限修饰符大于或等于父类的权限修饰符（子类方法对父类方法的扩展）
Final修饰的方法不能被重写

抽象类

抽象类：当所有子类都具有某个具体的行为，但是所有子类的该行为的实现均各不相同（用abstract修饰的类）
使用抽象类：
	需要统一管理该行为，并且该行为的每个子类各不相同
抽象类：
	类体是不完整的类，不能创建对象
	比普通方法多了一个抽象方法
内容：
	1、抽象方法：
		用abstract修饰并且没有方法体的方法
	2、成员变量
	3、成员方法
	4、构造方法（给子类创建对象是调用）
用法：
	子类继承父类时，某类行为只需要有方法的定义，并且每种子类该行为各不相同
注意：	
	1、抽象类创建对象只能通过向上造型创建
	2、不能使用final关键字修饰（因为抽象类必须要有子类才具有意义，而是用final修饰的类不能）
  	定义：
 	访问修饰符 abstract class 类名{}
  	抽象类 必须要有子类才有意义
  	构建 子类对象 前 先构建父类对象（必须要有子类才有意义）

抽象方法

抽象方法：
	使用abstract修饰，没有方法体的方法
   public abstract class 方法名();

内部类

定义在类中的类，内中类仅仅作为外部类的一个成员来用，地位和成员变量和成员方法一样

1、成员内部类

成员内部类：
	将一个类作为另一个类的成员使用时
注意：
    当成员内部类时非static的情况下，在内部类中不能定义static内容
    当外部类的成员与内部类的成员重名时，使用外部名.this.成员
public class Demo {
	public static void main(String[] args) {
		//创建成员内部类对象：
        Person p = new Person();
		Person.Eyes e = p.new Eyes();
	}
}
class Person{
	private String name;
	private String sex;
	class Eyes{//属于Person对象的类
		private String color;
		private String size;
		private String name;
		public void output(){
                                                         System.out.println(Person.this.name);
        System.out.println(sex);
		}
	}
}

2、匿名内部类：

/*	1、没有类名的类
	2、一般为方法内部类（为了重写被继承的类中的方法）
	3、定义时需要体现该匿名内部类与其他类的继承关系
	4、不能有构造方法
	
	5、不能有静态变量
	6、不能有静态方法
	（即不能有static修饰的内容）
*/
用法：
    确认某个类的子类在程序执行过程中，只创建一次对象，则使用匿名内部类

//小括号()后面的 整个{} 为没有类名的内部类
TimerTask task = new TimerTask(){
    public void run(){}//TimerTask类中有的方法，（这里是重写run方法）
    //可以定义自己独有的方法，但在类外面不能使用（外面使用没意义），只能自己用自己，方法功能多的时候，可以用来把多个功能分开，方便使用
    public void test(){}
};

static

静态的
    使用static修饰的东西 存在方法区中
    使用static修饰的东西 是所有对象共用一个
方法区：仅有一分
    类对象、static修饰的成员
使用位置：
    1、在static修饰的成员方法中：
        1)、不能使用非静态的成员
        2)、非静态方法也不能访问
    2、使用static修饰的成员变量：
        通常用类名.进行调用
    3、静态块（static{}）：
       给静态变量赋初值使用的，并且该 进行块 只会执行一次
       调用：在程序执行之前 编译器自动调用，并且只调用一次

public static void main(String[] args){
    Aoo a = new Aoo();
    System.out.println(a.a);
    System.out.println(a.b);
    //使用类名. 调用
    System.out.println(Aoo.b);
}
class Aoo{
    int a;
    
    static int b;
    //给静态变量赋初值
    static{
        b = 100;
    }
    public void test(){}
    public static void test2(){}
}

final

1、修饰类
	类不能被继承
2、修饰方法
	方法不能被重写
3、修饰变量
	1）、修饰成员变量：必须赋初值
	2）、修饰局部变量：只需要在使用前赋初值即可
	变量赋值一次之后，变量不能被改变

常量（static final）

static final 共同修饰的变量
只能修饰成员变量（只能是成员变量）
	定义时，需要同时初始化
	不能修改，
	建议：常量名全大写
	如果常量名有多个单词组成时，多个单词之间用下划线（_）连接
	例如：
	public static final int HEIGHT = 10;
注意事项：
用于修饰类 --》不能被继承（String Integer Short Byte Character等类不能被继承)
用于修饰方法--》不能被重写
用于修饰变量--》不能被修改（如果用于修饰成员变量那么在定义时必须初始化，如果修饰局部变量，在使用之前进行初始化即可）

接口

接口：用于定义规范（定义标准）
	 可多继承
interface 接口名{
	int A  = 100;
	只能有常量，不能有普通成员变量
	不能有构造方法
	不能有普通方法
	允许有抽象方法
}

可以有的成员方法：
	1、抽象方法
		public abstract void test();
		
JDK1.8版本后有：
	2、static静态方法
		public static void test2(){}
	3、使用default修饰的普通方法
		public default void test3(){}

接口中只允许有常量（接口中的成员变量一定是一个常量）
	定义int A = 100;
	int 前面默认有修饰常量的关键字（public static final）

有extends 和implments时，先继承再实现

类和接口的关系

类和接口之间：实现关系
	implements 实现
	class 类名implements 接口名{
		重写接口中的抽象方法
	}