了解封装、继承和多态

目录

封装

封装的作用

继承

继承规则

protected权限修饰符

 super关键字

修饰属性：表示直接从父类中去寻找同名属性

修饰方法：表示直接从父类中去寻找方法

 多态

向上转型

方法重写(override)

向上转型发生的时机

调用方法

 

 判断向下转型是否安全

---

封装

封装就是把对象的属性和行为封装起来，让使用该类的用户不能直接的操作里面的数据。使用权限修饰符进行封装操作。如private修饰的变量不能直接使用，需要调用对应的set和get方法来使用。

封装的作用

1. 封装可以保护内部数据使其更安全，提高了程序的可维护性。

2.提高了代码的复用性

3.降低了耦合度

继承

继承规则

1.要是用继承，前提必须满足类之间的 is a 关系

2.一个类只能使用extends继承一个父类（单继承），但可以使用多层继承

例如表示只能单继承

可以多层继承

3.子类会继承父类的所有属性和方法，显示继承（public 属性和方法可以直接使用）隐藏继承（private属性和方法）子类其实也继承这个属性和方法，但是无法直接使用

protected权限修饰符

protected作用域：同包内可见，不同包中的子类可见

同包中不同类，可以访问

不同包中，不可以访问 

 

不同包中的子类，可以访问

 super关键字

修饰属性：表示直接从父类中去寻找同名属性

当有继承关系时 this关键字默认现在当前类中寻找同名属性，若没找到，继续向上寻找父类中是否有同名属性，直接使用name，编译器默认都是this.name。

当B中有name属性时调用B的neme属性n

class A {
    public String name = "A";

}


public class B extends A{
    String name ="b";
    public void print(){
        System.out.println(name);
    }

    public static void main(String[] args) {
        B b = new B();
        b.print();
    }
}

当B中没有name属性时调用父类A中的name属性

class A {
    public String name = "A";

}

public class B extends A{
    public void print(){
        System.out.println(name);
    }

    public static void main(String[] args) {
        B b = new B();
        b.print();
    }
}

修饰方法：表示直接从父类中去寻找方法

1.修饰构造方法

 在构造方法的中当没有写super()会默认有super()，这个只能调用无参构造

 class A {
    public String name = "A";

    public A() {
        System.out.println("A的无参构造");
    }
}

public class B extends A{
    public int i;
    public B() {

    }

    public B(int i) {
        this.i = i;
    }

    public void print(){
        System.out.println(name);
    }

    public static void main(String[] args) {
        B b = new B();
        B b1 = new B(1);
//        b.print();
    }
}

当父类A中没有无参构造，B类构造方法默认调用A类无参构造就会出错

class A {
    public String name = "A";

    public A( String name) {
        System.out.println("A的有参构造");
    }

}

public class B extends A{
    public int i;
    public B() {

    }

    public B(int i) {
        this.i = i;
    }

    public void print(){
        System.out.println(name);
    }

    public static void main(String[] args) {
        B b = new B();
        B b1 = new B(1);
//        b.print();
    }
}

 super（父类构造方法的参数）调用父类构造方法

 class A {
    public String name = "A";

    public A() {
        System.out.println("A的无参构造");
    }

    public A( String name) {
        System.out.println("A的有参构造");
    }

}


public class B extends A{
    public int i;
    public B() {
    }

    public B(int i) {
        super("B");
        this.i = i;
    }


    public void print(){
        System.out.println(name);
    }

    public static void main(String[] args) {
        B b = new B();
        B b1 = new B(1);
//        b.print();
    }
}

 一个构造方法中this()和super()无法同时出现

 2.修饰方法，直接从父类中寻找同名方法

A类中的test方法

B类中的testB方法 

B类中调用

 

 多态

一个引用可以表现出多种类型就是多态

向上转型

向上转型使参数统一化，降低了使用者的难度

向上转型发生在有继承关系的类之间   父类名称 父类引用 = new 子类对象(); 不一定是直接子类，也可以是间接子类，如B继承A ， C继承B 则可以 A a = new C(); 

向上转型是自然发生的，向上转型发生后 最顶端的父类可以指向所有子类；

方法重写(override)

发生在有继承关系类之间，子类定义了和父类除了除了权限不同，其他全部相同的方法，这样的一组方法称为方法重写。子类不能重写父类中private修饰的方法。

方法的重写，访问权限不能更低可以更高。抛出的异常不能更多可以更少。

被子类重写的方法可以在方法名的上一行写上@override表示子类重写了父类的方法而且可以检查重写是否成功

public class Animal {
    public void eat(){
        System.out.println("动物吃东西");
    }
}

public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("小狗吃骨头");
    }
}

public class Bird extends Animal{
    @Override
    public void eat() {
        System.out.println("小鸟吃虫子");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal dog = new Dog();
        Animal bird = new Bird();
        allEat(dog);
        allEat(bird);
    }

    public static void allEat(Animal animal){
        animal.eat();
    }
}

向上转型发生的时机

引用赋值时发生向上转型，传递参数时发生向上转型

返回参数时发生向上转型 

 

调用方法

父类名称 父类引用 = new 子类对象(); 发生线上转型

使用父类引用调用普通方法时，如果子类重写了父类的方法，则调用该子类对象重写后的方法

 Dog和Bird都重写了Animal的eat方法，调用时不会调用Animal的eat方法，而是调用各自的eat方法

毫无关系的两个类之间没有办法强转 

如下：本来就是动物，但动物不一定是狗，所以转型失败。

这里本质animal1是一只狗，只是向上转型把它变成了动物，其实本质还是一只狗，所以向下转型把它本质暴露出来。所以转型没有错误

 

 判断向下转型是否安全

想下转型可能会发生异常，所以使用  instanceof来判断

为true表示可以向下转型，false不能向转型