2.面向对象

面向对象思想概述

**概述：**Java语言是一种面向对象的程序设计语言，而面向对象思想是一种程序设计思想，我们在面向对象思想的指引下， 使用Java语言去设计、开发计算机程序。 这里的对象泛指现实中一切事物，每种事物都具备自己的属性和行为。面 向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算 机事件的设计思想。 它区别于面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去 操作实现。

**特点：**面向对象思想是一种更符合我们思考习惯的思想，它可以将复杂的事情简单化，并将我们从执行者变成了指挥者。 面向对象的语言中，包含了三大基本特征，即封装、继承和多态。

类：是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该 类事物。
属性：就是该事物的状态信息。
行为：就是该事物能够做什么。

对象：是一类事物的具体体现。对象是类的一个实例，必然具备该类事物的属性和行为。

类与对象的关系：

• 类是对一类事物的描述，是抽象的。
• 对象是一类事物的实例，是具体的。
• 类是对象的模板，对象是类的实体。

成员变量的默认值：

封装

概述：面向对象编程语言是对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。 封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的 方式。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。

原则：将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问。

1. 使用 private 关键字来修饰成员变量。
2. 对需要访问的成员变量，提供对应的一对 getXxx 方法 、 setXxx 方法。
3. 当一个对象被创建时候，构造方法用来初始化该对象，给对象的成员变量赋初始值。

继承

继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接 访问父类中的非私有的属性和行为。
好处：1. 提高代码的复用性。 2. 类与类之间产生了关系，是多态的前提。

父类子类重名访问成员变量规则：
直接通过子类对象访问成员变量:
等号左边是谁， 就优先用谁，没有则向上找。
间接通过成员方法访问成员变量:
该方法属于谁，就优先用谁，没有则向上找。

如果局部变量，子类变量和父类变量重名：
局部变量:直接写成员变量名
本类的成员变量:
this .成员变量名
父类的成员变量:
super.成员变量名

在父子类的继承关系当中，创建子类对象，访问成员方法的规则: .
创建的对象是谁，就优先用谁，如果没有则向上找。
注意事项:
无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类的。|

继承关系中，父子类构造方法的访问特点:

1. 子类构造方法当中有一个默认隐含的“super()"调用，所以一定是先调用的父类构造，后执行的子类构造。
2. 子类构造可以通过super关键字来调用父类重载构造。
3. super的父类构造调用，必须是子类构造方法的第一个语句。 不能一个子类构造调用多次super构造。
   总结:
   子类必须调用父类构造方法，不写则赠送super();写了则用写的指定的super调用，super只能有一 个，还必须是第一个。

super关键字用法：
super关键子的用法有二种:
1.在子类的成员方法中，访问父类的成员变量。
2.在子类的成员方法中，访问父类的成员方法。
3.在子类的构造方法中，访问父类的构造方法。

this关键字用法：
1.在本类的成员方法中，访问本类的成员变量。
2.在本类的成员方法中，访问本类的另一个成员方法。
3.在本类的构造方法中，访问本类的另一个构造方法。

java语言是单继承的，一个类的直接父类只有一个

重写(Override）

方法重写 ：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。
@override 检测重写是否正确
返回值，权限修饰符不必须一样，子类方法的返回值必须小于等于父类方法的返回值范围。子类方法的权限必须大于等于父类方法的权限修饰符。

抽象类

• 父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有 意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法 的类就是抽象类。

• 使用 abstract 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。

• 如果一个类包含抽象方法，那么该类必须是抽象类。

• 继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该父 类的抽象方法，否则，从最初的父类到最终的子类都不能创建对象，失去意义。

• 抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。

• 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

• 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

• 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象 类。

接口

接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么 接口的内部主要就是封装了方法，包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方法 （JDK 9）。 接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并 不是类，而是另外一种引用数据类型。
接口的使用，它不能创建对象，但是可以被实现（ implements ，类似于被继承）。一个实现接口的类（可以看做 是接口的子类），需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象类。

接口中可以包括：

1. 常量 （java7）
2. 抽象方法 （java7）
3. 默认方法 （java8）
4. 静态方法 （java8）
5. 私有方法 （java9）

注意事项:
接口当中的抽象方法，修饰符必须是两个固定的关键字: public abstract （可以选择性省略）

public interface MyInterfaceAbstract {

      public abstract void methodAbs1();

             abstract void methodAbs2();

               public void methodAbs3();

                      void methodAbs4();
    
}

实现接口必须重写所有抽象方法。

如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类。|

从java8开始接口可以有默认方法，可以解决接口升级问题，不修改实现类的情况下给接口增加方法

1.接口的默认方法，可以通过接口实现类对象，直接调用。
2.接口的默认方法，也可以被接口实现类进行覆盖重写。

public interface MyInterfaceDefault {

          public abstract void methodAbs(); //新添加了一个抽象方法
         
          public default void methodDefault() {     //新添加的方法，改成默认方法
              System.out.println( "这是新添加的默认方法");
}

从java8开始接口可以写静态方法

不能通过接口实现类的对象来调用接口当中的静态方法，通过接口名称可以直接调用静态方法

我们需要抽取一个共有方法，用来解决两个默认方法之间重复代码的问题。
但是这个共有方法不应该让实现类使用，应该是私有化的。

从Java 9开始，接口当中允许定义私有方法。
1.普通私有方法，解决多个默认方法之间重复代码问题
格式:
private 返回值类型 方法名称(参数列表) {
方法体
}
2.静态私有方法，解决多个静态方法之间重复代码问题
格式:
private static 返回值类型 方法名称 (参数列表) {
方法体
}

接口当中也可以定义“成员变量”，但是必须使用public static final三个关键字进行修饰。
从效果上看，这其实就是接口的常量。接口当中的常量必须赋值。使用完全大写，常量分隔。

接口不能有构造方法和静态代码块，一个类可以同时实现多个接口。

父类方法和接口默认方法冲突，优先父类，继承优于实现

1.类与类之间是单继承的。直接父类只有一一个。
2.类与接口之间是多实现的。一个类可以实现多个接口。
3.接口与接口之间是多继承的。

注意事项:
1.多个父接口当中的抽象方法如果重复，没关系。
2.多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，而且带着default关键字。

多态

多态： 是指同一行为，具有多个不同表现形式。
代码当中体现多态性，其实就是一句话：父类引用指向子类对象

• 父类名称 对象名 = new 子类名称();
• 接口名称 对象名 = new 实现类名称();|

成员变量:编译看左边，运行还看左边。
成员方法:编译看左边，运行看右边。

向上转型一定是安全的，没有问题的，正确的。但是也有一个弊端:
对象一旦向上转型为父类，那么就无法调用子类原本特有的内容。向下转型可进行还原，类似于强制类型转换

final关键字

子类可以在父类的基础上改写父类内容，比如，方法重写。那么我们能不能随意的继承 API中提供的类，改写其内容呢？显然这是不合适的。为了避免这种随意改写的情况，Java提供了 final 关键字， 用于修饰不可改变内容。

final： 不可改变。可以用于修饰类、方法和变量。

• 类：被修饰的类，不能被继承。
• 方法：被修饰的方法，不能被重写。
• 变量：被修饰的变量，不能被重新赋值。

public final class：
final关键字：最终的，不可改变的
final修饰的类不能被继承，这个类不能有任何的子类，方法不能被重写，相当于太监类
final修饰的方法是最终的，不能被重写 abstract 关键字和final关键字冲突，不能一起用
final修饰一个局部变量，一旦使用final用来修饰局部变量，那么这个变量就不能进行更改，相当于常量，基本类型一次赋值，终生不变，引用类型地址值不变，内容可变。
final修饰一个成员变量，由于成员变量具有默认值，final修饰必须手动赋值，要么直接赋值，要么构造方法赋值，包括所有重载的构造方法。

instanceof关键字：
animail instanceof Dog
这将会得到一个boolen值结果，也就是判断前面的对象能不能当做后面类型的实例。
方法参数传递存在自动类型转换，向上转型

权限修饰符

在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限

• public：公共的。
• protected：受保护的
• default：默认的
• private：私有的

内部类

成员内部类：
内用外，随意访问;外用内，需要内部类对象。

如何使用成员内部类?有两种方式:

1. 间接方式:在外部类的方法当中，使用内部类;然后main只是调用外部类的方法
2. 直接方式，公式:
   类名称 对象名= new 类名称();
   [外部类名称.内部类名称 对象名 = new 外部类名称(). new内部类名称();]

Body.Heart heart = new Body(). new Heart() ;

如果出现了重名现象，那么格式是:外部类名称. this.外部类成员变量名|

public class Outer {
		int num = 10; //外部类的成员变量
		public class Inner /*extends object*/ {
		int num = 20; //内部类的成员变量
		public void methodInner() {
		int num = 30; //内部类方法的局部变量
		System. out .println(num); //局部变量，就近原则
		System. out . println(this.num); //内部类的成员变量
		System. out . println(Outer.this.num); // 外部类的成员变量
     }
}

匿名内部类：

如果接口的实现类(或者是父类的子类)只需要使用唯一的一次，
那么这种情况下就可以省略掉该类的定义，而改为使用[匿名内部类]。
匿名内部类的定义格式:
接口名称 对象名=new.接口名称() {
//覆盖重写所有抽象方法
};

1. 匿名内部类在创建对象的时候只能使用唯一次
2. 匿名对象，在[调用方法]的时候，只能调用唯一一次。如果希望同一个对象，调用多次方法，那么必须给对象起个名字。
3. 匿名内部类是省略了[实现类/子类名称]，但是匿名对象是省略了[对象名称]|