Java学习笔记（三）：面向对象

1.继承

• 语法

  class 父类｛｝
  class 子类 extends 父类｛｝

  只能多层继承，不能多重继承,子类不能直接访问父类中的私有成员，可通过getter和setter方法获得
• 子类对象new实例化（时）

1. 会默认先调用父类的构造方法，再调用子类的构造方法去实例化所以，若父类和子类构造方法里含有输出语句，会在new时都打印
2. 实际上，子类构造里隐含了super();调用了父类构造

• 方法的覆写（“方法重写”）

1. 子类覆写的方法不能拥有比父类方法更加严格的访问权限
   （如：父类--public ,子类也必须是--public ）
2. 父类方法被子类方法覆写后，如何访问该父类方法？
   ```
3. 使用super();关键字即可,如：super.print();
4. 在子类中，直接通过“super.方法（）”形式即可访问父类中的方法
   ```
5. .特例:private-->到default不算覆写，而是重新定义了一个新的方法！

• 属性的覆写

1. 继承后重新定义属性，同覆写方法一致

2. 特别：在子类中:

   1.super.name-->访问父类中的name属性
   2.this.name-->访问“本“类中的name属性

• 重载与覆写的区别

1. 重载:

   01.方法名相同参数类型或个数不同
   02.对权限没有要求
   03.发生在同一个类中

2. 覆写：

   01.方法名称，参数类型相同
   02.被覆写的方法（即子类方法）不能拥有（比父类方法）更严格的访问权限
   03.发生在继承类中

• super关键字的作用

1. super调用父类构造

   **同this一样，该语句必须放在构造方法的句首**

2. this与super的区别：

this：

01.属性：调用本类中的属性，若没有，则从父类中寻找
02.方法：调用本类中的方法，若没有，则从父类中寻找
03.构造：调用本领构造，必须放在构造方法的首行
04.特殊：表示当前的对象

super：

01.属性：访问父类中的属性
02.方法：直接访问父类中的方法
03.构造：调用父类构造，必须放在子类的构造方法里的首行，如：super();

• final关键字

注意：

1. 使用final声明的“类‘’不能有子类
2. 使用final声明的”方法”不能被子类所覆写
3. 使用final声明的变量即为常量，常量不可修改！
4. public static final同时声明的变量称为全局”常“量

2.抽象类

• 定义规则
  ```

1. 包含一个抽象方法的类必须是抽象类
2. 抽象类和抽象方法都要使用abstract关键字声明
3. 抽象方法只需声明而不需要实现
4. 抽象类必须被子继承，子类（如果不是抽象类）必须覆写抽象类中的全部抽象方法
5. 抽象类不能直接实例化，必须经由非抽象子类进行子类的实例化
   ```

• 定义格式
  ```

1. 抽象类：abstract class A ｛｝
2. 抽象方法：访问权限 abstract 返回值类型 方法名称（参数）;
   //在抽象方法中是没有方法体的，不需要｛｝
3. 子类的定义方法：class B extends A{ }
   在子类还必须覆写抽象类中的全部抽象方法
4. 注意：抽象方法不要用private关键字声明，因为抽象方法必须被子类覆写

5. 本质：抽象类比普通类多了个抽象方法，除了不能直接进行对象的实例化操作外其实并没有不同
   ```

   3.接口

• 组成：

1. 最重要的概念之一

2. 由全局常量和公共的抽象方法组成

   扫描二维码关注公众号，回复： 91707 查看本文章

   interface 接口名称 {
   全局常量;
   抽象方法;
   }

3. 此处的抽象方法必须定义为public 访问权限，不可更改！！！
4. 当然，也可不写，默认public ,而不是default

5. 通常，我们知道，全局常量是public static final,抽象方法是public abstract，但此处特殊，默认所以可省略该定义，实际上还有的

interface A{
    String s="作者"; //定义全局常量
    void print(); //定义抽象方法
    String getInfo(); //抽象方法不需{}
}

• 接口的使用

1. class 子类名 implements 接口A,接口B{ } ！！！
   一个子类可以实现多个接口，class A implements B,C{}
2. 实现后，必须覆写全部抽象方法

• 接口的继承

1. 一个接口不能继承抽象类，但一个接口允许继承多个接口

   interface A{} interface B{} interface C extends B,C{}

2. 即一个接口可以同时继承多个接口，注意是继承extends!!!

3. 接口不能实现接口，可以实现继承

   4.对象的多态性

• 两种

1. 方法的重载和覆写
2. 对象的多态性
   01.向上转型：子类对象-->父类对象,会自动完成
   02.向下转型：父类对象-->子类对象,必须指定转型的子类类型

• 格式

1. 对象向上转型：父类 父类对象 =子类实例;

   如：B b =new B(); //子类实例化过程
     A a =b; //向上转型

2. 对象向下转型：子类 子类对象 =（子类）父类实例;

   如：A a =new B(); //向上转型
   B b =(B)a; //向下转型：A-->B

• 调用:调用子类自己的方法，一定只能用子类的实例化对象
• 注意:！！！在进行对象的向下转型前，必须首先发生对象的向上转型，否则将异常

• 读法:一个程序要从右到左:

  如：A a =new B();
  是B实例化了一个对象，该B的对象再向上转型成为了A的对象a

  5.instanceof关键字

• 用于判断一个对象到底是谁哪个类的实例

1. 对象 instanceof 类 -->返回boolean值

• 用途:

1. 如下：

   A a1=new B(); 
   A a2=new A();

   01.a1同时是A和B的对象-->通过子类实例化的对象同时也是父类和子类的实例，所以可以直接向上或向下转型
   02.a2只是A的对象 -->此时不能向下转型，因为没有先向上转型-->直接使用父类实例化本类对象，就不再是子类实例了，所以不能转型

2. 向下转型前进行判断操作,避免异常
   ```
   A a=new B();
   if( a instanceof B){ }