继承与多态

类和对象（二）

继承

1.为什么会有继承？
打个比方：比如说人，有名字，年龄，会吃饭，睡觉（都是人相同的共性）
但有些人会些不同的东西不相同：比如说有的人会打篮球，会打乒乓球，这些是他们特有的。
（简单来说就是对共性的抽取）
用关键字extends来表示，子类extends父类

class Person {
    public String name;
    public int age;

    public Person() {
    }
    public Person(String name) {
        this.name=name;
    }

    public void eat() {
        System.out.println(name+ "在吃饭");
    }

    public void sleep() {
        System.out.println(name + "正在睡觉");
    }
}

class Student extends Person{

    public Student(String name) {
        super(name);
    }
    public void play() {
        System.out.println(name+ " 打乒乓球");
    }
}

class Teacher extends Person {

    public Teacher() {
        super();
    }
    public void play() {
        System.out.println(name+ " 打篮球");
    }
}
public class Main {
    public static void main(String[] args) {
        Student student1 = new Student("zhangsan");
        System.out.println(student1.name);
        student1.eat();
        student1.play();
    }
}

如果子类中没有找到该成员和方法，就会去父类中寻找
super关键字，该关键字主要作用：在子类方法中访问父类的成员。
在创建Students对象时，传了个字符串，调用Students中带字符串的构造方法，super(name);就会跑去调用父类的带一个参数的构造方法，执行完父类的构造方法，回到自己的构造方法，且super()必须是子类构造方法中第一条语句。
要是没有写构造方法，编译器就会自带一个不带参数的构造方法

静态代码块与代码块与构造方法

class Person {
    public String name;
    public int age;
    public Person() {
        System.out.println("构造方法");
    }
    {
        System.out.println("代码块");
    }

    static {
        System.out.println("静态代码块");
    }
}

public class Main {
    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("=========");
        Person person2 = new Person();
    }
}

结论：静态代码块>代码块>构造方法
且静态代码块只会执行一次

protected关键字

package Text;

public class Student {
    protected int hight;
}//Studets与Person在不同的包，这里为了方便看，这么写

import Text.Student;
class Person extends Student {
    public void gethight() {
        super.hight=180;
        System.out.println(super.hight);
    }
}

public class Main {
    public static void main(String[] args) {
        Person person1 = new Person();

        person1.gethight();

多态

想要知道什么是多态必须要满足如下几个条件，缺一不可：

1. 必须在继承体系下
2. 子类必须要对父类中方法进行重写
3. 通过父类的引用调用重写的方法

重写

那么什么是重写？
被重写的前提必须是具有父子关系的
其次：返回值类型 方法名 参数列表 要完全一致，子类访问权限要大于等于父类的访问权限

class Person{
    public String name;
    public int age;

	public Person(String name){
        this.name=name;
    }
    public void eat() {
        System.out.println(name+ " 吃饭");
    }

    public void play() {
        System.out.println(name +"正在跑步");
    }
}

class Student extends Person{
	public Student(String name) {
        super(name);
    }
    public void play() {
        System.out.println(name +"正在打乒乓球");
    }//重写play方法
    public void swim() {
        System.out.println(name +"正在游泳");
    }
}

class Teacher extends Person{
	public Teacher(String name) {
        super(name);
    }
    public void play() {
        System.out.println(name +"正在打篮球");
    }//重写play方法
}

public class Main {
    public static void main(String[] args) {
    		
    }
}

向上转型

父类类型 对象名 = new 子类类型()

Person student1 = new Student("zhangsan");
        student1.play();
        //student1.swim();不能访问子类中的方法，只能方问父类中的成员和方法
        Person teacher1 = new Teacher("lisi");
        teacher1.play();

谢谢观看！！！