继承、重载、重写、多态、抽象类、接口、Static

继承：你继承什么你就有什么，继承是一种严格的父子关系。

如果⼀个类没有明确继承⽗类，那么就表示默认继承 Object 类 （这个父类不一定是直接父类，孙子可以使用爷爷的方法） 。

---

OOP : Object  Oriented Programming 面向对象编程

Java是单继承，就是 一个类只能继承extends一个类， 但是java里面是 支持实现多个接口 。

Java只支持单继承，实现多重继承三种方式：（1）直接实现多个接口 （2）扩展(extends)一个类然后实现一个或多个接口  （3）通过内部类去继承其他类

----Java 不允许多重继承 ----- 但是允许使⽤多层继承 ----

多 重 继承

Class  A{}

Class  B{} 

Class  C extends A,B{}

这种多重的继承在 java ⾥⾯是不被允许使⽤的，只要使⽤就会报错。

多 层 继承

Class  A{}

Class  B  extends  A{}

Class  C  extends  B{}

这种多层继承相当于爷孙三代，爷爷 A —— 爸爸 B —— 孙⼦ C ；虽然这种多层继承在 Java ⾥⾯不限制继承

层数，但是为了代码逻辑清晰，在实际开发当中，最好不要超过三层

关于继承（super（））：

public class Student extends Person {

private String className;

public Student() {

//new Person();不写的话 默认给加上super();

System.out.println("Student.Student");

}

//this.x:当前类的x对象

//super();代表调用父类的构造方法

public Student(int id, String name, int age, String gender, String className) {

//Java 里面 new 的时候，首先把父类对象 new出来,super(x);之 前不能写任何代码

//new Person(id,name,age,gender);

//super(id, name, age, gender);//不写的话会默认加一个无参的super();

this.className = className;//不写super(id, name, age, gender);的话 只能得到className

System.out.println("Student.Student2");

}

---

附加：在⼦类对象构造之前⼀定会默认调⽤⽗类的⽆参构造，以保证⽗类的对象先实例化，再实例化

⼦类对象。

⼦类可以直接将⽗类的操作继续使⽤，属于代码重⽤；

⼦类可以继续扩充⾃⼰的标准

---

提高代码复用性。

将所有子类共有的属性和方法抽取到父类里面，子类继承父类，那么父类里面的属性和方法相当于子类里面也有。

-private:只在当前类里面可以访问（子类也不能访问）

+public：任何地方都可以访问

#protected： 对于父类里面想让子类继承的，一般设置为 protected

---

方法的重载： overload

在同一个类里面，允许存在一个以上同名方法，只要他们参数类型和参数个数不同即可。参数的类型、顺序和个数不同。

构造方法重载（无参构造方法、有参构造方法）

方法重载特点： 与返回值无关，只看参数列表。

void show(int a, char b, double c){}

1、void show(int x, char y, double z){}   不是重载，是同一个方法 

2、int show(int a, double c, char b){}      是重载， 顺序不一样也是重载

3、void  show(int a, double c, char b){}   是重载

4、boolean show(int c, char b){}           是重载

5、void show(double c){ }                     是重载

6、double show(int x, char y, double z){}  不是重载

---

重写（覆盖）@Override：toString()

概念：重写指的是在Java的子类与父类中有两个名称、参数列表都相同的方法的情况。由于他们具有相同的方法签名，所以子类中的新方法将覆盖父类中原有的方法。

1、子类覆盖父类，必须保证子类权限大于父类权限才可以覆盖，否则会编译失败。

2、如果父类是private的方法，子类是默认方法，那么子类是不知道这个方法的，不是覆盖。

  重写条件：（全面）

1、重写方法的参数列表必须完全与被重写方法的参数列表相同；

2、返回类型必须完全与被重写方法的返回类型相同；

3、访问级别的限制性一定不能比被重写方法的强；

4、访问级别的限制性可以比被重写方法的弱；

5、重写方法一定不能抛出新的检查异常或比被重写的方法声明的检查异常更广泛的检查异常；

6、重写的方法能够抛出更少或更有限的异常（也就是说，被重写的方法声明了异常，但重写的方法可以什么也不声明）；

7、不能重写被标示为final的方法；

8、如果不能继承一个方法，则不能重写这个方法。

重载（Overload）： 同一个类中看同名方法的参数列表。（构造方法重载）

重写（Override）： 父子类方法要一模一样

---

多态 ：

面向接口（抽象）编程 

关于Person person = new Student();的知识点

public class Add extends Cal {

//ctrl + o 重写父类里面的方法

public Add() {

super();

}

public Add(int num1, int num2) {

super(num1, num2);

}

// 不管 父类的getResult是不是抽象方法，子类都是重写

@Override

public int getResult() {

//super：代表父类对象

//Add add = new Add();

//add.getResult();

//对象.方法() 调用，调用getResult()方法时候，

//肯定已经new出来Add这个对象，new子类对象的时候一定已经把父类对象Cal已经new出来

//return super.getResult();

return num1 + num2;

}

}

public static void main(String[] args) {

//声明成子类类型，new子类对象,

// 如果子类重写了getResult方法

//那么调用的就是子类重写后的方法

//若果子类没有重写，调用的是从父类继承的方法

Add add = new Add(3, 5);

int result = add.getResult();

System.out.println(result);

//声明成父类类型，new子类对象

// 如果子类重写了getResult方法

//那么调用的就是子类重写后的方法

//若果子类没有重写，调用的是从父类继承的方法

Cal cal = new Add(3,5);//父类类型是可以指向子类类型的，通过指向不同的对象可以表现出不同的行为

int result1 = cal.getResult();

System . out .println( result1 );

//cal 声明成的是父类类型即可以指向new 出来的Add对象

//又可以指向new 出来的Sub对象

Cal cal1 = new Sub(3,5);

System.out.println(cal1.getResult());

}

---

抽象类：

1、抽象方法是没有方法体，如果这个类里面有抽象方法，这个类必须变成抽象类。

2、如果这个类是抽象类，并不要求这个类一定要有抽象方法

3、抽象类里面可以有普通方法，也可以有抽象方法。

4、如果一个类是抽象类，那么这个类就不能被new实例化，只能被其他类继承。

5、抽象方法可以理解为父类（抽象类）定义的一个模板或者规范（自己本身不实现），

子类必须实现这个抽象方法。如果子类不想实现这个方法，那么这个子类也必须要变成抽象类。

接口interface：

接口是一个纯粹的抽象类（接口可以没有方法，如果有里面所有的方法都是抽象方法 ， jdk1.8后接口中的方法可以有方法体，jdk1.8之前不可以有方法体 ）

接口就是一个规范，他没有提供任何实现，具体的功能由实现接口的子类去实现。 （若要实现一个接口为普通类则必须实现接口的所有抽象方法）

接口也可以继承接口（可以继承多个接口），但不能实现接。！！！！！！！！！

接口就是一个规范，可插拔（可以被替换，首先定义一个标准（接口），大家都遵守这个标准，就可以实现互相之间替换）

1、 接口是一个纯粹的抽象类 ，接口里面的方法都是抽象方法 public abstract（不写的话会自动提供）。

2、接口里面所有的属性public static final

接口和抽象类的区别

相同点： （1）都不能被实例化 （2）接口的实现类或抽象类的子类都只有实现了接口或抽象类中的方法后才能实例化。

不同点： （1）接口只有定义，不能有方法的实现，java 1.8中可以定义default方法体，而抽象类可以有定义与实现，方法可在抽象类中实现。

（2）实现接口的关键字为implements，继承抽象类的关键字为extends。一个类可以实现多个接口，但一个类只能继承一个抽象类。所以，使用接口可以间接地实现多重继承。

（3）接口强调特定功能的实现，而抽象类强调所属关系。

（4）接口成员变量默认为public static final，必须赋初值，不能被修改；其所有的成员方法都是public、abstract的。抽象类中成员变量默认default，可在子类中被重新定义，也可被重新赋值；抽象方法被abstract修饰，不能被private、static、synchronized和native等修饰，必须以分号结尾，不带花括号。

抽象类可以有构造方法,只是不能直接创建抽象类的实例对象而已

在接口中 不可以有构造方法,在接口里写入构造方法时，编译器提示：Interfaces cannot have constructors。

---

final:最终的意思

final变量：这个变量就不能被修改，常量，一般用大写   public static final double PI  = 3.1415;

final类：这个类就不能被继承

final方法：这个方法就不能被重写

---

继承和接口中关于父类指向子类和子类指向子类的区别：

public void test1() {

   DaYan daYan = new DaYan();

    daYan.egg();

    daYan.fly();

    daYan.print();

   

    // bird是站在AbstractBird这个类角度去看new出来的DaYan这个对象，

    // 所以只能看到egg()这个方法

   AbstractBird bird = new DaYan();

    bird.egg();

    // bird.fly();

    // bird.print();

   

    // 站在能不能飞IFly的角度去看DaYan，只能看到fly()这个方法

   IFly fly = new DaYan();

    fly.fly();

    //fly.egg();

    //fly.print();

    fly = new GeZi();

    fly.fly();

}

---

继承和接口的区别：

继承是严格的父子关系，你继承什么你就是什么：鸽子就是鸟。

父类是抽取了所有子类的共同特征， 父类里面的属性和方法是所有子类所共有的属性和方法。

接口是一个标准，一般用在能不能具有某个功能。

把能不能飞定义称为一个接口IFly，实现了这个接口的类就具有了这个功能。

---

静态static： 静态属性、静态方法

1.在同一个类中：

1.在静态方法中可以直接使用静态成员

2.在非静态方法中可以直接使用非静态成员

3.在非静态方法中可以直接使用静态成员

4.在静态方法中是不可以直接使用非静态成员的

如果想用：

static  void test1(){

TestC tc = new TestC();// new 构造方法的调用

// 类的实例化：将某个类创建出一个对象

tc.test2()；// 标准调用格式： 对象 . 非静态方法 / 变量

TestC.test3();// 静态成员调用格式： 类名.静态方法

}

2.在不同类中

TestC tc = new TestC();

tc.实例成员；

静态属性调用有两种方式：

1.对于静态属性可以使用：类名 . 属性 的方式调用 直接 TestC.静态成员

2.对象.属性   tc.静态成员（语法规则成立，但不推荐这样用）

附加： 关于static{}块的解释：

     只是在执行main之前执行的一些语句而已，并不是说里面的变量就是static的，没什么特别的。

     临时变量只在static这个大括号中有用。

使用时候： 

1、静态的方法只能访问静态的方法和静态的属性（因为当前对象的实例可以没有创建，

所以静态的方法是没办法调用非静态的方法和属性的）

2、静态的方法中不能写this、super关键字(因为当前的对象实例可能还没有创建，

代表当前类对象的this还有代表父类对象的super可能都还没有创建)

非静态的属性和方法（实例属性和方法）必须通过new对象访问，而静态的属性和方法

是属于类的，在类加载到内存中就可以访问，被所有对象所共享。

---

工具类：Math

把和数学运算相关的放在了一起

public class MathUtil {

private MathUtil () {

}

public static int max(int num1, int num2) {

return num1 > num2 ? num1 : num2;

}

public static int min(int num1, int num2) {

return num1 < num2 ? num1 : num2;

}

}

public static void main(String[] args) {

//生成返回值 crtl + alt + v

//int max = Math.max(3, 6); //Math的构造方法是私有的

//如果方法是实例的不是静态的 就需要new一个对象来调用

//MathUtil mathUtil = new MathUtil();

//int maxValue = mathUtil.max(3, 4);

//System.out.println(maxValue);

//把方法写成静态的static，不用new一个对象，直接 类.方法（）

//因为new一个对象的话浪费资源

//为了防止它new一个对象，一般让他的构造方法私有，这样就不能被实例化了（单例模式），直接就可以 “类.方法（）”来调用；

MathUtil.max(3, 4);

Math .min( 3 , 4 );

---