JAVA封装 继承 多态

1.面向对象程序三大特性:封装,继承,多态

封装:将数据和操作数据的方法结合,隐藏对象的属性和实现细节,仅对外公开接口来和对象进行交互。

2.访问限定符

访问权限可以限定类中成员的可见性,也可以控制类的可见性

JAVA主要通过类和访问权限来实现封装:类将数据及封装数据的方法结合在一起,访问权限用来控制方法或者字段能否直接在类外使用。

范围:

private:同一个包中的同一个类

default:同一个包中的同一个类,同一个包中的不同类(包访问权限,默认 例:成员变量 int a的权限 default)

protected:同一个包中的同一个类,同一个包中的不同类,不同包中的子类

public:公开,同一个包中的同一个类,同一个包中的不同类,不同包中的子类,不同包中的非子类

3.包的概念:把多个类收集在一组

导包:使用import语句导包

4.自定义包:package语句

IDEA:右键src->新建->包(包名) ;右键包名->新建->类(类名 class)

鼠标右键 generate->Getter/Setter自动生成get/set方法;constructor自动生成带参数的构造方法,tostring重写

5.继承:抽取共性,实现代码复用

什么继承? 对共性进行抽取 为什么继承?达到代码的复用

继承之后,子类可以复用父类中成员,子类在实现时只需要关心自己新增加的成员即可;

标识继承关系 要用到 extends关键字

修饰符 class 子类 extends 父类{ }

package demo1;



 class Animal {
    public String name;
    public int age;
    public String color;
    public void eat(){
        System.out.println(name+"正在吃饭!");
    }

}
class Dog extends  Animal{
    public void wangwang(){
        System.out.println(name+"汪汪叫");
    }

}
class Cat extends Animal{
    public  void mimi()
    {
        System.out.println(name+"喵喵喵");
    }
}

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

        Dog dog=new Dog();
        dog.name="乐乐";
        dog.eat();
        dog.wangwang();
        System.out.println("===========");
        Cat cat =new Cat();
        cat.name="咪咪";
        cat.eat();
        cat.mimi();


    }
}

1)父类成员访问

成员变量访问遵循就近原则,自己有优先自己的,如果没有则向父类中找(访问的成员变量与父类成员变量同名,则有先访问自己的)成员方法同样;

2)super关键字(如何在子类中访问父类相同名称的成员变量?)

直接访问是无法做到的.super关键字的作用就是在子类方法中访问父类的成员,只能在非静态的方法中使用

3)子类构造方法

子类对象构造时,需要先调用基类构造方法,在执行子类的构造方法

因为:子类对象成员是有两部分组成,基类继承下来的以及子类新增加的部分。所以先将基类(父类)继承下来的成员构造完整,然后再调用子类自己的构造方法,将子类自己新增加的成员初始化完整。

用户没有写时,或父类显式定义无参的构造方法,编译器会自动调用(添加)基类的无参构造方法(super()),而且super()必须是子类构造方法中的第一条语句,并且只能出现一次

如果父类构造方法是有参数的,用户需要为子类显式定义构造方法,并选择合适的父类构造方法调用

public class Base {
    public Base(){
        System.out.println("Base无参构造方法");
    }
}
class Test extends Base{
    public  Test(){
        //默认有Base()
        System.out.println("Test构造方法");
    }
}
class Main{
    public static void main(String[] args) {
        Test test =new Test();
        
    }
}

4)继承方式

JAVA中不支持多继承(一个类继承两个类)

单继承 

多层继承

不同类继承同一个类

6.super 和 this不同点

this是当前对象的引用,super相当于子类对象中从父类继承下来部分成员的引用

this不仅可以访问父类也可以访问子类 super只能访问从父类继承过来的成员变量

7.final关键字:修饰变量,成员,类

1)修饰变量或者字段 表示常量(不能被修改)

2)修饰类表示该类不能被继承

protected关键字

8.组合:类类型来做成员变量

组合和继承类似,也是表达类之间的关系方式

继承 is-a 组合 has-a

9.多态:多种形态

去完成某个行为,不同的对象会产生不同的状态

1)多态的实现条件:

必须要在继承体系下

子类必须要对父类中方法进行重写

向上转型

通过父类的引用调用这个子类重写的方法

体现:在代码运行时,传递不同类对象时,会调用对应类中的方法

 2)重写(覆盖)

重写是子类对父类非静态,非private,final修饰,非构造方法等实现过程进行重新编写,返回值和形参 方法名都不改变;

重写:子类可以根据需要(实现父类的方法),定义特定的属于自己的行为

方法名,参数列表(类型,个数,顺序),返回值必须相同

访问权限不能比父类中被重写的方法访问权限低

可以使用@Override注解显式指定

静态绑定:(前期绑定)在编译时根据用户传递的实参类型确定具体调用哪个方法  (方法的重载是静态绑定,在编译的时候通过方法的参数就能确定调用的是哪个方法)

动态绑定:(后期绑定)在编译时,不能确定方法的行为,需要等程序运行时,才能确定具体调用哪个类的方法

向上转型(有3种方式)

1)直接赋值

创建一个子类对象,将其当成父类对象来使用(小范围向大范围转换)

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

package demo1;



 class Animal {
    public String name;
    public int age;
    public String color;
    public void eat(){
        System.out.println(name+"正在吃饭!");
    }

     public Animal(String name) {
         this.name = name;
     }
 }
class Dog extends  Animal{
     //在子类构造方法之前先调用父类构造方法
     public Dog(String name){
         super(name);
     }

    public void wangwang(){
        System.out.println(name+"汪汪叫");
    }
    public void eat(){
        System.out.println(name+"正在吃狗粮");
    }



}
class Cat extends Animal{
    public Cat(String name) {
        super(name);
    }

    public  void mimi()
    {
        System.out.println(name+"喵喵喵");
    }
    public  void eat(){
        System.out.println(name+"正在吃猫粮");
    }
}

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

      Animal animal1=new Dog("乐乐");
        animal1.eat();

    }
}

上述通过父类引用调用父类和子类重写的方法就是动态绑定(多态的基础) 

 

2).方法传参 

3)方法返回 

 向上转型的缺点;不能调用子类特有的方法

4)向下转型

将子类对象向上转型之后当成父类方法使用,在无法调用子类方法,有时候需要调用子类特有的方法,再将父类引用还原为子类对象即可,为向下转型

if(animal1 instanceof Cat){
cat=(Cat)animal1;}

要转型为原来的类型,转换失败会抛异常,引入instanceof提高转型的安全性,该表达式为true可以安全转换