1、封装

1.1 定义

隐藏对象内部的属性和实现细节，仅对外公开接口来和对象进行交互。

例如对于电脑这样一个复杂的设备，提供给用户的就只是：开关机、通过键盘输入，显示器，USB插孔等，让用户来和计算机进行交互，完成日常事务。但实际上电脑真正工作的却是CPU、显卡、内存等一些硬件元件，而这些元件并不直接对用户开放。

1.2 作用

• 不需要关注对象内部细节，只需关注对象暴露出来的接口，简化和对象交互
• 只能通过对象暴露出的接口，进行对对象的访问，规范了对象访问的方式
• 对对象内部数据结构进行保护

1.3 Java封装的实现

Java中主要通过类和权限修饰符来实现封装，类可以将数据和操作数据的方法结合在一起，更符合人类对事物的认知，权限修饰符用来控制，外部对类内部数据的访问。

权限范围：

权限使用：

• 类只能被public和default进行修饰
• 类的成员变量和成员方法可以被public、protected、default、private进行修饰

【注】当父类和子类不在同一个包内，子类对于父类内被protected修饰的成员，只能通过super进行访问。

2、继承

2.1 定义

抽取对多个类的共同属性和行为到某个类，其他的类进行继承，可以实现对这些属性和行为的复用，无需重复定义。如果子类需要扩展可以重写父类方法，或者添加新的属性和方法。

2.2 作用

代码的复用

2.3 继承实现

通用extends关键字进行继承

public class Animal{    protected String name;    protected void eat(){            }} /**  * Dog继承了Animal的name和eat()  */public class Dog extends Animal{    protected String name;    protected void eat(){            }}

【注】

• 子类会将父类中的成员变量或者成员方法继承到子类中去
• 子类继承父类之后，必须要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承了

2.4 继承原则说明

2.4.1 构造器调用

调用子类构造方法产生子类对象之前，默认调用父类的构造方法先产生父类对象而后产生子类对象

2.4.2 Java中的单继承局限

Java中不允许多重继承，但允许多层继承

Java中一个类只能使用extends继承一个父类，不能同时extends继承多个父类

如下继承语法时错误

public class A{}public class B{}//这种语法时错误的public class C extends A,B{}

2.4.3 super关键字

2.4.3.1 super访问属性

super.属性名 访问的时父类的属性

1）当子类有属性和父类同名时，访问的是子类属性，输出的是子类属性值

public class Parent {    protected String name = "爸爸";}class Son extends Parent{    protected String name="儿子";    public void printInfo(){        System.out.println(super.name); //输出“爸爸”        System.out.println(name);  //输出“儿子”    }    public static void main(String[] args) {        Son son = new Son();        son.printInfo();    }}

输出结果如下图：

2）当子类没有属性和父类同名时，访问的是父类的属性，输出的是父类属性值

public class Parent {    protected String name = "爸爸";}class Son extends Parent{        //protected String name="儿子";  //注释掉看输出的效果    public void printInfo(){        System.out.println(super.name); //输出“爸爸”        System.out.println(name);  //也是输出“爸爸”    }    public static void main(String[] args) {        Son son = new Son();        son.printInfo();    }}

输出结果如下图：

2.4.3.2 super调用构造器

1）父类有默认的无参构造器，子类构造器会默认去调用父类的无参构造器

public class Parent {    public Parent(){        System.out.println("爸爸1");    }    public Parent(String name){        System.out.println(name);    }}class Son extends Parent{    public Son(){        System.out.println("儿子");    }    public static void main(String[] args) {        Son son = new Son();    }}

输出结果如下图：

2）父类没有默认的无参构造器，子类构造器需要手动去调用父类的其他构造器

父类注释默认无参构造器后报错：

父类注释掉默认的无参构造器后，子类构造器内部去调用父类其他构造器，编译通过

2.4.3.3 super访问普通方法

super访问普通方法，逻辑同访问属性一致，这里不再赘述，可参考2.4.3.1

2.4.3.4 总结

• this表示当前对象的成员变量或方法的调用
• super表示父类对象的成员变量与方法的调用
• 当父类中不存在无参构造，则子类构造方法的首行必须使用super（参数）显式调用父类中的有参构造。

2.5 final

1）修饰变量或字段，表示常量(即不能修改)

final int a = 10;a = 20; // 编译出错

2）修饰类表示此类不能被继承

final public class Animal {...}public class Bird extends Animal {...}// 编译出错Error:(3, 27) java: 无法从最终com.bit.Animal进行继承

我们平时使用的 String 字符串类, 就是用 final 修饰的, 不能被继承

3）修饰方法，表示方法不能被重写

3、多态

3.1 定义

当同一种类型的对象，去做同一种行为的时候，所体现的效果不同。

例如打印机有彩色打印机和黑白打印机，它们都有”打印文件“的行为，但是打印的文件颜色效果不同，这就是多态的一种体现。

3.2 多态的条件

• 必须发生继承
• 子类要重写父类方法
• 通过父类的引用调用重写的方法

多态在代码中体现

/** * 打印机 */public abstract class Printer {    protected void print(){        System.out.println("打印出未知颜色的文件");    }}/** * 黑白打印机 */class BlackWhitePrinter extends Printer{    @Override    protected void print() {        System.out.println("打印出黑白的文件");    }}/** * 彩色打印机 */class ColorfulPrinter extends Printer{    @Override    protected void print() {        System.out.println("打印出彩色的文件");    }}class Runner{    public static void main(String[] args) {        Printer pr1 = new BlackWhitePrinter();        Printer pr2 = new ColorfulPrinter();        //pr1和pr2都是用Printer类型的引用进行引用，打印出效果不同，体现了多态。        pr1.print();        pr2.print();    }}

上述代码，基类为Printer,BlackWhitePrinter和ColorfulPrinter都继承了Printer，并重写了Printer的print()，调用的时候，BlackWhitePrinter和ColorfulPrinter的对象都是用Printer类型的变量进行引用，调用了同一个方法，但是产生的效果不同，这是多态的体现。

输出结果如下：

3.3 重写

3.3.1 重写的定义

• 重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程 进行重新编写, 返回值和形参都不能改变
• 重写的好处在于子类可以根据需要，定义特定 于自己的行为。 也就是说子类能够根据需要实现父类的方法。

3.3.2重写的规则

• 子类在重写父类的方法时，一般必须与父类方法原型一致： 返回值类型 方法名 (参数列表) 要完全一致
• 被重写的方法返回值类型可以不同，但是必须是具有父子关系的
• 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类方法被public修饰，则子类中重写该方 法就不能声明为 protected
• 父类被static、private修饰的方法、构造方法都不能被重写。
• 重写的方法, 可以使用 @Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验. 例如不小心 将方法名字拼写错了 (比如写成 aet), 那么此时编译器就会发现父类中没有 aet 方法, 就会编译报错, 提示无法 构成重写.

3.3.3重写和重载的区别

3.4 向上和向下转型

3.4.1 向上转型

定义

向上转型：实际就是创建一个子类对象，将其当成父类对象来使用。

语法格式：父类类型 对象名 = new 子类类型()

Animal animal = new Cat("元宝",2);

使用场景

• 直接赋值
• 方法传参
• 方法返回

public class TestAnimal {    // 2. 方法传参：形参为父类型引用，可以接收任意子类的对象    public static void eatFood(Animal a){        a.eat();    }    // 3. 作返回值：返回任意子类对象    public static Animal buyAnimal(String var){        if("狗".equals(var) ){            return new Dog("狗狗",1);        }else if("猫" .equals(var)){            return new Cat("猫猫", 1);        }else{            return null;        }    }    public static void main(String[] args) {        Animal cat = new Cat("元宝",2); // 1. 直接赋值：子类对象赋值给父类对象        Dog dog = new Dog("小七", 1);        eatFood(cat);        eatFood(dog);        Animal animal = buyAnimal("狗");        animal.eat();        animal = buyAnimal("猫");        animal.eat();    }}

【注】

• 向上转型的优点：让代码实现更简单灵活。
• 向上转型的缺陷：不能调用到子类特有的方法。

3.4.2 向下转型

将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的 方法，此时：将父类引用再还原为子类对象即可，即向下转换.

public class TestAnimal {    public static void main(String[] args) {        Cat cat = new Cat();        Dog dog = new Dog();        Animal animal = cat; //向上转型        animal.eat(); //输出“cat eat",当前实际类型为Cat        animal = dog; //指向dog对象        animal.eat(); //输出“dog eat",,当前实际类型为Dog       // cat = (Cat)animal;  //animal类型为Animal,实际类型为Dog,向下转型为Cat，虽然编译通过，但是运行时报错       // cat.mew();                dog = (Dog)animal; //animal引用类型为Animal,实际类型为Dog,向下转型为Dog，编译通过，运行也能通过        dog.bark();            }}class Animal{    protected void eat(){};}class Cat extends Animal{    @Override    protected void eat() {        System.out.println("cat eat");    }    public void mew(){        System.out.println("喵喵");    }}class Dog extends Animal{    @Override    protected void eat() {        System.out.println("dog eat");    }    public void bark(){        System.out.println("汪汪");    }}

向下转型用的比较少，而且不安全，万一转换失败，运行时就会抛异常。Java中为了提高向下转型的安全性，引入 了 instanceof ，如果该表达式为true，则可以安全转换。

public class TestAnimal {    public static void main(String[] args) {        Cat cat = new Cat();        Dog dog = new Dog();        Animal animal = cat; //向上转型        animal.eat(); //输出“cat eat",引用类型为Animal,当前实际类型为Cat        animal = dog; //指向dog对象        animal.eat(); //输出“dog eat",引用类型为Animal,当前实际类型为Dog        if (animal instanceof Cat) { //判断实际类型是否为Cat            cat = (Cat)animal;              cat.mew();        }        if (animal instanceof Dog) { //判断实际类型是否为Dog            dog = (Dog)animal;            dog.bark();        }    }}class Animal{    protected void eat(){};}class Cat extends Animal{    @Override    protected void eat() {        System.out.println("cat eat");    }    public void mew(){        System.out.println("喵喵");    }}class Dog extends Animal{    @Override    protected void eat() {        System.out.println("dog eat");    }    public void bark(){        System.out.println("汪汪");    }}