第四节——继承与多态

Posted 2021-08-18 想学习安全的小白

继承的学习

一、继承的特性

1. 子类拥有父类非 private 的属性(成员变量，类似但不全是)、方法。
2. 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

多态的学习

一、多态的概念

多态：同一个对象，在不同时刻表现出来的不同的态

//声明一个Test类，里面写一个test方法
public class Test {
    public void test(){
        System.out.println("test");
    }
}

//再声明一个Test1类，继承与Test类，并对test方法进行重写
public class Test1 extends Test{
    @Override
    public void test() {
        System.out.println("test1");
    }
}

//实现Test1这个类的多态
Test test1 = new Test1();
test1.test();  //输出test1

二、多态的前提

1. 有继承/实现关系
2. 有方法重写
3. 有父类引用指向子类对象，比如：Test test = new Test1();

三、多态的注意事项

1. 虽然多态创建的是子类的实例化对象，但是不能访问子类特有的属性与方法，特有属性只能在子类重写的方法中调用
   eg：

//定义一个Test类，这个类有a属性和test方法
public class Test {
    public int a=10;
    public void test(){
        System.out.println("test");
    }
}

//再定义一个Test1类，这个类继承了Test类，并且有自己的属性b和方法test1
public class Test1 extends Test{
    public int b=30;
    @Override
    public void test() {
        System.out.println(b);
    }
    public void test1(){
        System.out.println("test1");
    }
}

//对Test1类进行性多态的实现
Test test1 = new Test1();
//1.对于Test1里面的特有属性不能直接访问
int a=test1.b;//会报错
//2.Test1里面的特有方法不能访问
test1.test1();//会报错
//3.对于Test1里面的特有属性b，可以通过重写的方法test()进行使用
test1.test();//打印30

2. 对于使用多态实例化的子类对象，访问共有的属性时，通过类中方法访问，使用的时子类重写后的值；通过对象名访问时，使用的是父类中的值，其原因是：方法有重写概念，成员变量没有重写概念

/定义一个Test类，这个类有a属性和test方法
public class Test {
    public int a=10;
    public void test(){
        System.out.println("test");
    }
}

//再定义一个Test1类，这个类继承了Test类，并重写方法test，重新定义了a的值。
public class Test1 extends Test{
    public int a=20;
    @Override
    public void test() {
        System.out.println(a);
    }
}

//对Test1类进行性多态的实现
Test test1 = new Test1();
//1.使用对象名使用a属性，使用的是父类中的a值
System.out.println(test1.a);//打印的是10
//2.使用子类中的方法访问a属性，使用的是子类中的值
test1.test();//打印20

三、多态的具体使用

1. 需求分析，Test1与Test2类都继承自Test类，并都重写了test方法，在qwe类中执行Test1类与Test2类的test方法
2. 不使用多态：

//声明Test类
public class Test {
    public void test(){
        System.out.println("test");
    }
}
//声明Test1类，并重写test方法
public class Test1 extends Test{
    @Override
    public void test() {
        System.out.println("test1");
    }
}
//声明Test2类，并重写test方法
public class Test2 extends Test{
    @Override
    public void test() {
        System.out.println("test2");
    }
}
//声明qwe类，让Test1与Test2在qwe里面执行test方法
public class qwe {
    public void test1(Test1 t1){
        t1.test();
    }
    public void test2(Test2 t2){
        t2.test();
    }
}
//使用qwe类的方法
qwe a = new qwe();
a.test1(new Test1());//等同于Test1 t1 = new Test1();a.test1(t1);
a.test2(new Test2());

3. 使用多态：当很多个Testn类继承自Test，且都需要在qwe类中执行test方法，可以使用多态进行调用

//修改qwe类的成员方法
public class qwe {
    public void test(Test t){ //Test t = new Test1()
        t.test();
    }
}
//使用qwe类的方法
qwe a = new qwe();
a.test1(new Test1());
a.test2(new Test2());

四、转型

1. 向上转型：父类引用指向子类对象，eg：Test test1 = new Test1();
2. 向下转型：父类引用转为子类对象
   eg：

Test test1 = new Test1();//此时test1不能使用Test1类里面的特有方法
Test1 t1 = (Test1)test1；//使用向下转型，t1就可以使用Test1里面的特有方法