继承，多态

继承

Java体系中所有的类默认继承Object类

如果想要明确说明两个类之间的继承关系，必须要使用关键字 extends

public class Pet{
   private String name;
   private int age;
   public void setName(String name){
       this.name = name;
   }
   public String getName(){
       return name;
   }
}
public class Dog extends Pet{
    String color;
}
public class Bird extends Pet{
    boolean fly;
    
}

super关键字

super : 上一级的对象，但是super只能调用构造方法，或者属性和行为。不能将super关键字作为对象返回。

必须用在构造方法中的第一行，因为子类如果想要调用构造方法进行创建对象，那么必须要先调用父类构造。

public class Pet{
   private String name;
   private int age;
   public Pet(String name,int age){
       this.name = name;
       this.age = age;
   }
}
public class Dog extends Pet{
    private String color;
    public Dog(String name,int age,String color){
        super(name,age);
       
        this.color = color;
    }
}
public class Bird extends Pet{
    boolean fly;
    public Bird(String name,int age,boolean fly){
        super(name,age);
        this.fly = fly;
    }
    
}

方法的重载 overload

在同一个作用域中，出现相同的方法名，此时参数列表结构不同（类型，数量，顺序），则重载。

public class Car{
    public Car(){
        
    }
    public Car(String name,String color){
        
    }
    public void move(){
        
    }
    public void move(double speed){
        
    }
}

方法的重写（覆盖）override

要有继承关系，子类中出现和父类中相同的方法签名，并且子类中权限要大于等于父类权限，父类中private不能被重写，父类中方法是static，不能重写，父类中final修饰的方法，也不能重写。

public class Pet{
    public void eat(){
        
    }
}

public class Dog extends Pet{
    public void eat(){
        System.out.println("狗吃肉");
    }
}
public class Cat extends Pet{
    public void eat(){
        System.out.println("猫吃鱼");
    }
}

多态

不同的对象，针对同一个行为方法，做出的不同表现形式，就是多态

有继承关系、重写、左边父类，右边子类引用

编译看左，运行看右

public class Pet{
    public void eat(){
        
    }
}
public class Dog extends Pet{
    public void eat(){
        System.out.println("狗吃肉");
    }
}
public class Cat extends Pet{
    public void eat(){
        System.out.println("猫吃鱼");
    }
}
public class Test{
    public static void main(String [] args){
        Pet dog = new Dog();
        Pet cat = new Cat();
		dog.eat();
        cat.eat();
    }
}

如果子类中出现自己独有函数方法，那么多态就可能有弊端

public class Pet{
    public void eat(){
        
    }
}
public class Dog extends Pet{
    public void eat(){
        System.out.println("狗吃肉");
    }
    public void run(){
        
    }
}
public class Test{
    public static void main(String [] args){
        Pet dog = new Dog();
		dog.eat();
        ((Dog)dog).run();
    }
}

造型，向上造型，向下造型（强制转换）

instanceof 关键字

一个对象是否属于一个类， 对象 instanceof 类名 ， 返回值是 boolean类型

public class Test {
    public static void main(String[] args) {
        Usb usb = new Usb();
        ShuBiao shuBiao = new ShuBiao();
        Upan upan = new Upan();
        usb.loading(shuBiao);
        usb.loading(upan);
    }
}
class Device{}
class Upan extends Device{
    public load(){
        System.out.println("u盘");
    }
}
class ShuBiao extends Device{
    public load(){
        System.out.println("鼠标");
    }
}
class Usb{
    public void loading(Device device){
        if(device instanceof Upan){
            ((Upan)device).load();
        }else if(device instanceof ShuBiao){
            ((ShuBiao)device).load();
        }
    }
}

static和final关键字

static 静态

可以修饰变量 ，修饰的变量叫做静态变量，类变量（共享）

可以修饰方法，修饰的方法叫做静态方法，类方法（共享）

类可以直接调用被static修饰的东西

static修饰的方法中，可以直接使用被static修饰的事物，不能直接使用非静态方法和非静态变量

this关键字，属于非静态变量

非静态方法中，可以直接使用静态变量（方法）和非静态变量（方法）

类的加载是有顺序的（jvm虚拟机运行原理）

public class Person{
    static int number;
    int a;
    public static void foo(){
        number++; 
    }
    public void fun(){
        number++;
        a++;
    }
}

final 最终的

可以修饰类，该类不能被继承

可以修饰变量，该变量必须要初始化赋值，并且不能修改，此时变量变为常量，规范：常量名全大写

可以修饰方法，该方法不能被重写。