Java2.2(继承、多态、抽象类、final关键字、static关键字、接口、object类)

继承

让类与类之间产生父子关系：被继承的类叫做父类(基类、超类)；继承的类叫做子类(派生类)

class 父类 {
//...
}
class 子类extends 父类 {
//...
}

//父类：
public class Parent {
    private String name;
    private int age;

    public Parent() {
    }
    public Parent(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
//子类：
public class Child extends Parent {

}
//测试：
public class Test1 {
    public static void main(String[] args) {
        Child c = new Child();
        c.setName("liya");
        System.out.println(c.getName());
    }
}

子类中什么也没有定义，但是测试类中却可以引用，因为子类继承了父类所有的数据、方法等。
案例：两个类，狗和猪，都含有姓名、性别、年龄和吃，但是狗狗还可以看家，猪还会打鼾

//animal:
public class Animal {
    private String name;
    private int age;
    private String sex;

    public Animal() {
    }

    public Animal(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    public void eat() {
        System.out.println("吃饭");
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}
//Dog类：
public class Dog extends Animal {

    public void watch() {
        System.out.println("看家");
    }
}
//Pig类:
public class Pig extends Animal {
    public void snore() {
        System.out.println("哼哼");
    }
}
//测试类：
public class Test1 {
    public static void main(String[] args) {
        Pig c = new Pig();
        Dog d = new Dog();
        d.setName("汪汪");
        System.out.println(d.getName());
        c.snore();
        c.eat();
        d.eat();
    }
}

继承中成员变量的使用特点
Java中使用变量遵循“就近原则”，局部位置有就使用；没有就去本类的成员位置找，有就使用；没有就去父类的成员位置找，有就使用，没有就报错。
访问父类变量：super.父类变量名；
this和super
this是使用方法所属类中的值，super是使用父类中的值
局部变量、本类的成员变量和父类的成员变量重名了：
直接写变量名： 局部变量
this.成员变量名： 本类的成员变量
super.成员变量名： 父类的成员变量

public class 优快云 {
    public static void main(String[] args) {
      Child c = new Child();
      c.show();
    }
}
class Parent {
  int num = 30;
}
class Child extends Parent {
  int num = 20;
  public void show() {
    int num = 10;
    System.out.println(num);         //输出10，本方法中的num
    System.out.println(this.num);    //输出20,Child类中的num
    System.out.println(super.num);   //输出30,父类Parent中的num
  }
}

（子类所有构造方法的第一行都有一个默认的super()用来访问父类的无参构造方法，如果父类没有无参构造，可以通过super(参数)的形式访问父类的带参构造）
方法的重写
子类中出现和父类方法定义相同的方法的现象，方法名、参数列表、返回值类型必须都相同(父类私有方法无法重写，子类方法的访问权限不能小于父类方法)
访问权限修饰符：
private：强调的是给自己来使用
默认(不写)：强调的是给同包下的类来使用
protected：强调的是给子类使用
public：强调的是给大家使用

方法重载和重写的区别：

多态

要有继承；要有方法重写；父类引用指向子类对象

public class Test {
public static void main(String args[]) {
     //父类引用指向子类对象
     Animal a = new Dog();
     }
}

多态使用场景：父类型可以作为形参的数据类型，这样可以接收其如任意的子类对象

public static void shouAnimal(Animal an) {
}

多态关系中成员变量的使用：
（多态关系中，成员变量是不涉及到重写的）多态关系中，使用成员变量，遵循“编译看左，运行看左”
编译看左：在编译期间会看左边的类型有没有这个成员，没有就报错，有就不报错。
运行看左：意思是在运行期间使用的是 左边类型中的这个成员

抽象类

包含抽象方法的类，用abstract修饰
抽象方法：只有方法声明，没有方法体的方法，用abstract修饰，具体实现延迟到子类。

抽象类特点：
1.抽象类和抽象方法必须用abstract关键字修饰
2.抽象方法不能实例化，抽象类要通过创建其子类对象来完成初始化操作
3.抽象类的子类：如果是普通类，则必须重写所有的抽象方法；如果是抽象类，则不用重写抽象方法
抽象类的成员：
1.可以有普通的成员变量，也可以有成员常量
2.可以由抽象方法，也可以有非抽象方法
3.有构造方法，并且构造方法还可以重载
总结：抽象类中的成员比普通类多一种：抽象方法，其他和普通类一样
子类一般都有两个构造方法：一个空参构造访问父类的空参构造，一个全参构造访问父类的全参构造。

final关键字

修饰类：不能被继承，但是本身可以继承其他类
修饰方法：不能被重写，不能与abstract共存，可以被重载
修饰变量：常量，只能赋值一次，命名大写
修饰引用型变量：地址值不能改变，属性值可以改变

static关键字

修饰类的成员变量：被本类所有对象共享，静态方法中没有对象this,访问不了非静态成员，
成员变量：类变量
成员方法：类方法
调用：

类名.成员变量名;
类名.成员方法名(参数);

接口

定义：interface 接口名 { }
类和接口之间是实现关系，用关键字implements来表示
class 类名 implements 接口名 { }

Object类

类层次结构最顶层的基类，所有类都直接或间接地继承自object类，所以，所有的类都是一个object(对象)
构造方法
Object():构造一个对象，所有子类对象初始化时都会优先调用该方法
成员方法
int hasCode():返回对象的哈希码值，该方法通过对象的地址值运行计算，不同对象的返回值一般不同
Class<?>getClass():返回调用此方法对象的运行时类对象
String toString():返回该对象的字符串表示
boolean equals():返回其他某个对象是否与此对象"相等"，默认情况下比较两个对象的引用，建议重写