面向对象

面向对象

步骤和功能在进行封装，封装时根据不同的功能，进行不同的封装，功能类似的封装在一起。。用的时候，找到对应的类就可以了。这就是面向对象的思想。

在Java文件中写两个类：一个基本的类，一个测试类。文件名称和测试类名称一致。基本类创建类，在测试类中new一个对象（类名 对象名 = new 类名();）。这时使用成员变量就可以直接打点调用（对象名.变量名），同样成员方法就可以：对象名.方法名（...）调用。

成员变量和局部变量的区别

1. 成员变量：在类中方法外；储存在堆内存；随着对象的创建而存在，随着对象的消失而消失；有默认初始化值。
2. 局部变量：在方法定义中或者方法声明上；储存在栈内存；随着方法的调用而存在，随着方法的调用完毕而消失；没有默认初始化值，必须定义，赋值，然后才能使用。
3. 局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。

面向对象的三大特征

封装(encapsulation)

是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

封装的原则

1. 将不需要对外提供的内容都隐藏起来。
2. 把属性隐藏，提供公共方法对其访问。

封装的好处

1. 隐藏实现细节，提供公共的访问方式
2. 提高了代码的复用性
3. 提高安全性。

关键字private

1. private是一个权限修饰符，可以修饰变量和成员方法，被private修饰的成员只能在本类中被访问。
2. private修饰后应该提供对应的get()和set()方法，传入数据和返回数据。

关键字this

当我们的局部变量和成员变量相同的时候，就会导致局部变量隐藏了成员变量。this可以解决这个问题。

this的特点

1. 是当前类的对象引用。它就代表当前类的一个对象。
2. 谁调用这个方法,那么该方法的内部的this就代表谁。

继承(inheritance)

子类对象is a父类中的对象

继承的概念

1. 继承：将多个子类的共性向上抽取到父类，来实现代码的复用性和维护性。
2. Java中可以通过extends修饰子类，使子类可以继承父类的非私有成员。
3. 继承的格式：class 子类名 extends 父类名 {} 。

继承的注意事项

继承的弊端

继承增加了代码的耦合性（一个类要完成某项功能要依靠另外的某些类叫耦合），软件设计原则是：高内聚（一个类单独完成某项功能的能力），低耦合。继承使类和类之间更依赖。

继承注意事项

1. Java中只支持单继承，但是支持多层继承。
2. object是所有类的顶层父类，所有类都直接或间接继承它。
3. 父类私有化的成员子类无法继承。
4. 构造方法不参与继承。如果父类有构造，因为子类继承父类的时候要继承或使用父类的数据，所以在子类初始化前让父类的构造先执行。创建子类对象的时候先执行父类的构造再执行子类的构造。
5. 子类不继承父类的构造方法，但是可以用super关键字访问父类的构造方法。

继承中变量访问原则

就近原则访问，先在局部中找，找不到再到本类中找，找不到再去父类找。

关键字super

1. super是父类的一个引用，可以使用super访问父类的数据（成员变量、成员方法、构造方法）。
2. 在每个类构造方法的第一行都会有一条默认语句super()，默认调用父类的空参构造来完成父类构造方法的初始化。如果父类不提供空参构造，那子类就传参去父类调用父类的有参构造。
3. super和this不能共存。this代表本类的一个引用，理解为本类的一个对象，那个对象调用方法this就代表谁。

方法重写

1. 子类中出现了和父类中一模一样的方法声明(方法名,参数列表,返回值类型)，就会发生方法重写，子类的方法覆盖父类的方法。
2. 当子类对父类的方法不满意时，想对父类的方法进行扩展，就可以采用方法重写
3. 用@override（注解）可以检测此方法是否是重写父类的。
4. 静态方法不属于对象，属于类，用类名调用，所以静态方法不算重写。

方法重写的注意事项

1. 因父类私有的方法子类无法继承，所以子类不能重写父类私有的方法。
2. 子类在重写父类的方法时，权限修饰符不能比父类的低，最好一样。
3. 静态方法不参与重写。
4. final修饰的方法不能重写。

方法重载

允许一个类中，出现多个同名方法，只要参数个数或参类型不同即可。

关键字final

由于继承中有一个方法重写的现象,而有时候我们不想让子类去重写父类的方法.这对这种情况Java就给我们提供了一个关键字: final（最终的）。final可以修饰变量、类、成员方法

1. final修饰变量时此变量变常量。
2. final修饰类时，类不能被继承。
3. final修饰方法时方法不能被重写，子类只能原封不动继承。
4. final修饰基本数据类型，数据的值不能被改变。final修饰引用数据类型，地址值不能被改变。

多态(polymorphism)

面向对象的三大特征最后一个
继承是多态的前提

多态的概念

1. 多态就是某个事物在某个时刻表现出来的不同状态。
2. 多态的三个必要条件：1. 要有继承。2.要有方法重写，没有就没意义。3.父类引用指向子类对象。

多态的注意事项

多态的好处

1. 提高代码的复用性和维护性。（继承的特点）
2. 提高了代码的扩展性。

多态中成员访问的特点

1. 以多态形式访问成员变量，使用的是父类单的变量。编译运行看左边。
2. 多态的形式访问成员方法，编译看左边运行看右边。
3. 创建子类对象的时候，会访问父类的构造方法，对父类的数据进行初始化。

多态的弊端

1. 不能访问子类独有的功能和属性。要想使用，必须向下转型：把父类的引用强制转换为子类的引用。
   向下转型有可能出现类型转换异常，注意new一个空间才能转。

抽象类

1. 抽象类就是Java中没有方法体的方法。类中如果有抽象方法，该类就定义为抽象类。
2. 抽象类和抽象方法必须有关键字abstract（抽象的）修饰。
3. 抽象类的格式为：abstract class 类名 {}
   抽象方法的格式为：public abstract void eat();
4. 抽象类可以没有抽象方法，有抽象方法的一定是抽象类。
5. 抽象类中可以有构造方法，是为了子类访问父类数据时初始化父类的。
6. 如果想让抽象类实例化，就要以多态的方式由具体的子类实例化。
7. 抽象类的子类必须是抽象类，或者重写所有方法的子类。

抽象类的成员特点

1. 抽象类的成员变量既可以是变量，也可以是常量。
2. 抽象类有用于子类访问父类数据初始化用的构造方法。
3. 抽象类的成员方法既可以是抽象的，也可以是非抽象的。
4. 关键字abstract不能和private、final、static关键字共存。
5. 如果一个抽象类没有抽象方法，那就不能创建对象。

接口

对象与生俱来的功能定义在类中很合理，但是局部对象的特性定义在类中就不合理了。不是天生具备的就不合适。如果有扩展功能，就要用接口来定义扩展功能。

接口的概念

1. 接口：用来定义一些扩展功能，那些事物将来要用接个功能，就可以实现这个借口然后做出具体实现。
2. 接口就是用来定义规范和规则的。
3. 用关键字interface来定义接口。将class改成interface。格式: interface 接口名 {}。类实现接口用implements表示，格式:class 类名 implements 接口名{}。
4. 接口中的功能没有具体实现。接口不能实例化，不能new对象。

接口的特点

1. 接口中成员变量的特点：全是静态的公共变量。没有变量一说。接口中成员变量前面有默认的修饰符。
2. 接口中没有构造方法，不能new对象。
3. 接口中的方法全是抽象方法，内有非抽象方法。方法前存在默认修饰符。

接口和接口。类和类的关系

1. 1. 类和类的关系：单继承，支持多层继承。
2. 类和接口的关系：实现关系，既可以单实现，也可以多实现。实现接口必须重写接口中所有方法。
3. 接口和接口的关系：继承关系，并且可以多继承。单继承一个类的同时可以多继承多个接口。

抽象类和接口的区别

1. 设计思想：抽取所有子类的共性，并强制子类对共性功能重写。接口定义的是整个继承体系当中的一些额外扩展功能，那些类想要具备扩展功能就可以具体实现某个接口。
2. 抽象类中有构造方法，接口中没有。
3. 抽象类中中既可以有抽象方法也可以由非抽象方法。接口中全是静态的公共变量。

jdk1.8之后，接口中可以定义一个默认方法，可以有方法的具体实现，必须用default修饰。子类实现后就可以用有具体体现的默认方法。可能为了弥补 类的单继承 的不足（子类可以继承多个接口）。