Java : 封装、继承、多态

封装

封装的概念

封装:将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。
例如:计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。

访问限定符

Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认知，而访问权限用来控制方法或者字段能否直接在类外使用。Java中提供了四种访问限定符：
可以修饰方法/成员/类

No	范围	private	default	protected	public
1	同一包中的同一类	Yes	Yes	Yes	Yes
2	同一包中的不同类		Yes	Yes	Yes
1	不同包中的子类			Yes	Yes
1	不同包中的非子类				Yes

public：可以理解为一个人的外貌特征，谁都可以看得到
default: 对于自己家族中(同一个包中)不是什么秘密，对于其他人来说就是隐私了
private：只有自己知道，其他人都不知道(被private修饰的属性,只能在当前类当中使用。什么是当前类?找大括号->类的大括号)

封装扩展之包

包的概念
为了更好的管理类，把多个类收集在一起成为一组，称为软件包。包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式，比如：一个包中的类不想被其他包中的类使用。包还有一个重要的作用：在同一个工程中允许存在相同名称的类，只要处在不同的包中即可。

导入包中的类

//但是这种写法比较麻烦一些, 可以使用 import语句导入包.例如:import java.util.Date;
//如果需要使用 java.util 中的其他类, 可以使用 import java.util.*
public class Test1 {
    public static void main(String[] args) {
        java.util.Date date = new java.util.Date();// 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
    }
}
//但是我们更建议显式的指定要导入的类名. 否则还是容易出现冲突的情况.
//如果util包和sql包都存在一个Date这样的类，就会出现歧义，编译出错，编译器也不知道要导入哪一个包中的类

import 和 C++ 的 #include 差别很大. C++ 必须 #include 来引入其他文件内容, 但是 Java 不需要。import 只是为了写代码的时候更方便. import 更类似于 C++ 的 namespace 和 using。

自定义包

• 在文件的最上方加上一个 package 语句指定该代码在哪个包中
• 包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 com.baidu1 ).
• 包名要和代码路径相匹配. 例如创com.baidu1 的包, 那么会存在一个对应的路径 com/demo1 来存储代码.
  如果一个类没有 package 语句, 则该类被放到一个默认包中.

如何新建一个包?

1. 在 IDEA 中先新建一个包: 右键 src -> 新建 -> 包
2. 在弹出的对话框中输入包名, 例如 com.baidu
3. 在包中创建类, 右键包名 -> 新建 -> 类, 然后输入类名即可
4. 在新创建的 Test.java 文件的最上方, 就出现了一个 package 语句

//package声明java文件在哪个包当中
package com.baidu;
public class Test3 {
    String name = "zhangsan";
}
//----------------------------
//同一个包中不同类可以访问
package com.baidu;
public class Test {
    public static void main(String[] args) {
        Test3 test3 = new Test3();
        System.out.println(test3.name);
    }
}
//------------------------------
//不同包不能访问
package com.baidu.baidu2;
import com.baidu.Test3;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: 86191
 * Date: 2023-03-20
 * Time: 15:38
 */
public class Test2 {
    public static void main(String[] args) {
        Test3 test3 = new Test3();
        System.out.println(test3.name);
    }
}

包的访问控制权限控制举例

//Test1位于com.baidu1包中，Test2位于com.baidu2
package com.baidu1;

import com.baidu2.Test2;
public class Test1 {
    public static void main(String[] args) {
        Test2 test2 = new Test2();
        System.out.println(test2.age);
        //System.out.println(test2.name);//会报错，name是default，不允许被其他包中的类访问
        System.out.println(test2.sex);//sex是私有的，不允许被其他类访问
    }
}

//--------------------------------------------
package com.baidu2;

import com.baidu1.Test1;
public class Test2 {
    String name = "张三";//不加访问权限默认是default
    public int age = 10;
    private String sex = "男";
}

继承

继承概念

继承(inheritance)机制：允许在保持原有类特性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用。

继承语法
修饰符 class 子类 extends 父类 {
// …
}

class Animal {
    public String name;
    public int age;
    public void eat() {
        System.out.println(name+" 正在吃饭");
    }
    public void sleep() {
        System.out.println(name+"正在睡觉");
    }
}
class Dog {
    //public String name;
    //public int age;
    public float weight;
    /*public void eat() {
        System.out.println(name+" 正在吃饭");
    }
    public void sleep() {
        System.out.println(name+"正在睡觉");
    }*/
    public void bark() {
        System.out.println(name+" 正在汪汪");
    }
}
class Cat {
    //public String name;
    //public int age;
    public String hair;
    /*public void eat() {
        System.out.println(name+" 正在吃饭");
    }
    public void sleep() {
        System.out.println(name+"正在睡觉");
    }*/
    public void CatchMouse() {
        System.out.println(name+" 正在抓老鼠");
    }
}
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        //dog类中并没有定义任何成员变量，name和age属性肯定是从父类Animal中继承下来的
        System.out.println(dog.name);
        System.out.println(dog.age);
        //dog访问的eat()和sleep()方法也是从Animal中继承下来的
        dog.eat();
        dog.sleep();
        dog.bark();
    }
}

1. 子类会将父类中的成员变量或者成员方法继承到子类中了
2. 子类继承父类之后，要新添加自己特有的成员，体现出与基类的不同。

Dog和Cat都继承了Animal类，其中：Animal类称为父类/基类或超类，Dog和Cat可以称为Animal的子类/派生类，继承之后，子类可以复用父类中成员，子类在实现时只需关心自己新增加的成员即可。
继承概念中可以看出继承最大的作用就是：实现代码复用

父类成员访问

子类中访问父类的成员变量

class Base {
    int a;
    int b;
    int c;
}
class Derived extends Base{
    int a = 199; // 与父类中成员a同名，且类型相同
    int b; // 访问从父类中继承下来的b
    public void method(){
        System.out.println(a); // 访问自己的a
        System.out.println(super.a);//通过super可以访问父类的成员的a
        System.out.println(c); // 子类没有c，访问的肯定是从父类继承下来的c
         System.out.println(d); //  编译失败，因为父类和子类都没有定义成员变量b
    }
}
public class Test1 {
    public static void main(String[] args) {
        Derived derived = new Derived();
        derived.method();
    }
}

在子类方法中 或者 通过子类对象访问成员时：

• 如果访问的成员变量子类中有，优先访问自己的成员变量。
• 如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。
• 如果访问的成员变量与父类中成员变量同名，则优先访问自己的

成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。

子类中访问父类的成员方法

class Base1 {
    int a;
    int b;
    public void methodA() {
        System.out.println("AAA");
    }
     public void methodB() {
        System.out.println("DDD");
    }
}
class Derived1 extends Base1{
    int a = 199; // 与父类中成员a同名，且类型相同
    int b; // 与父类中成员b同名，但类型不同
    int c;
    public void method() {
        System.out.println("CCC");
    }
    //methodA(char ch)和父类methodA()构成了重载,说明了方法的重载不一定要在同一个类中
    public void methodA(char ch) {
        System.out.println("BBB");
    }

    public void test() {
        methodB();//子类没有，调用父类的
        method();//当子类没有不带参数的method的方法时候就会调用父类
        method('c');//子类有带参数的method方法时，就会调用子类的method方法
    }
}

public class Test2 {
    public static void main(String[] args) {
        Derived1 derived = new Derived1();
        derived.test();
    }
}

• 通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到则访问，否则编译报错。
• 通过派生类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用方法适传递的参数选择合适的方法访问，如果没有则报错；

总结：成员方法没有同名时，在子类方法中或者通过子类对象访问方法时，则优先访问自己的，自己没有时再到父类中找，如果父类中也没有则报错.

super关键字

super关键字，该关键字主要作用：在子类方法中访问父类的成员。

//在子类方法中，如果想要明确访问父类中成员时，借助super关键字即可
class Base2 {
    int a;
    int b;
    public void methodA() {
        System.out.println("AAA");
    }
    public void methodB() {
        System.out.println("访问父类类中的methodB()");
    }
}
class Derived2 extends Base2{
    int a = 199;//  与父类中成员变量同名且类型相同
    int b;
    int c;
    public void methodB() {
        System.out.println("BBB");
    }
    public void methodA(char ch) {
        System.out.println("AAA");
    }
    public void test() {
        System.out.println(super.a);//访问父类成员中的a
        methodA('c');//访问子类中的methodA()
        super.methodB();//访问父类中methodB()
    }
}

public class Test3 {
    public static void main(String[] args) {
        Derived2 derived = new Derived2();
        derived.test();
    }
}

1. 只能在非静态方法中使用
2. 在子类方法中，访问父类的成员变量和方法。

子类构造方法

父子父子，先有父再有子，即：子类对象构造时，需要先调用基类构造方法，然后执行子类的构造方法。

class Base4 {
    public Base4() {
        System.out.println("Base()");
    }
}
class Derived4 extends Base4{
    public Derived4(){
    // super(); // 注意子类构造方法中默认会调用基类的无参构造方法：super(),
    // 用户没有写时,编译器会自动添加，而且super()必须是子类构造方法中第一条语句，
    // 并且只能出现一次
        System.out.println("Derived()");
    }
}
public class Test {
    public static void main(String[] args) {
        Derived4 d = new Derived4();
    }
}

在子类构造方法中，并没有写任何关于基类构造的代码，但是在构造子类对象时，先执行基类的构造方法，然后执行子类的构造方法，因为：子类对象中成员是有两部分组成的，基类继承下来的以及子类新增加的部分 。父子父子肯定是先有父再有子，所以在构造子类对象时候 ，先要调用基类的构造方法，将从基类继承下来的成员构造完整，然后再调用子类自己的构造方法，将子类自己新增加的成员初始化完整

1. 若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用基类构造方法
2. 如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。
3. 在子类构造方法中，super(…)调用父类构造时，必须是子类构造函数中第一条语句。
4. super(…)只能在子类构造方法中出现一次，并且不能和this同时出现

super和this的区别

super和this都可以在成员方法中用来访问：成员变量和调用其他的成员函数，都可以作为构造方法的第一条语句，那他们之间有什么区别呢？

相同点:

1. 都是Java中的关键字
2. 只能在类的非静态方法中使用，用来访问非静态成员方法和字段
3. 在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在

不同点:

1. this是当前对象的引用，当前对象即调用实例方法的对象，super相当于是子类对象中从父类继承下来部分成员的引用
2. 在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性
3. 在构造方法中：this(…)用来调用本类的构造方法，super(…)用于调用父类构造方法，两种调用不能同时在构造方法中出现
4. 构造方法中一定会存在super(…)的调用，用户没有写编译器也会增加，但是this(…)用户不写则没有

protected关键字

1. 声明为protected的方法和成员变量能被同一个包里的所有类所访问，就像默认修饰符package一样。
2. 能被该类的子类所访问，子类可以和父类不在一个包中。
3. 能被该类的子类所访问，子类可以和父类不在一个包中。
4. 在子类中，子类实例可以访问其从基类继承而来的protected方法，而不能访问基类实例的protected方法。

package Demo2;
public class Test1 {
    protected int a = 199;

    public static void main(String[] args) {
        Test1 test1 = new Test1();
        System.out.println(test1.a);
    }
}

//---------------------------------
package Demo2;
public class Test2 {
    public static void main(String[] args) {
        Test1 test1 = new Test1();
        System.out.println(test1.a);
    }
}

//---------------------------------
package Demo3;
import Demo2.Test1;
public class Test3  extends Test1 {
    public void func() {
        System.out.println(super.a);
    }
    public static void main(String[] args) {
        Test3 test3 =new Test3();
        test3.func();
    }
}

多态

多态的概念&重写&多态实现条件

多态的概念：就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

总的来说：同一件事情，发生在不同对象身上，就会产生不同的结果。

重写

 class Animal {
    String name;
    int age;
    public Animal(String name, int age){
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println(name + "吃饭");
    }
}
 class Cat extends Animal{
    public Cat(String name, int age){
        super(name, age);
    }
    public void eat(){
        System.out.println(name+"吃鱼~~~");
    }
}
 class Dog extends Animal {
    public Dog(String name, int age){
        super(name, age);
    }
    //与父类中的public void eat()方法重写
    public void eat(){
        System.out.println(name+"吃骨头~~~");
    }
}
public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat("元宝",2);
        Dog dog = new Dog("小七", 1);
        dog.eat();
    }
}

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

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

//动态绑定：也称为后期绑定(晚绑定)，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调用那个类的方法
 class Animal {
    String name;
    int age;
     Animal(String name, int age){
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println(name + "吃饭");
    }
}

 class Dog extends Animal {
    public Dog(String name, int age){
        super(name, age);
    }
    public void eat(){
        System.out.println(name+"吃骨头~~~");
    }
}
public class Test {
     public static void eat(Animal a) {
         a.eat();
     }
    public static void main(String[] args) {
        /* Dog dog = new Dog("wangcai",10);
        Animal animal = dog;*/
        Animal animal1 = new Dog("wangwang",11);
        animal1.eat();
        //1.父类与子类发生了重写
        //2.通过父类的引用调用eat方法，发生动态绑定
    }
}
//运行结果:
//wangwang吃骨头~~~

//-------------------------------------
//静态绑定:称为前期绑定(早绑定)，即在编译时，根据用户所传递实参类型就确定了具体调用那个方法。典型代表函数重载
public class Test2 {
    public int x;
    public int y;
    public int getx() {
        return x;
    }
    public int gety() {
        return y;
    }
    public int add(int a,int b) {
        return a+b;
    }
    public int add(int a,int b,int c) {
        return a+b+c;
    }
    public static void main(String[] args) {
        Test2 test2 = new Test2();
        int sum1 = test2.add(1,2);
        int sum2 = test2.add(1,2,3);
        System.out.println("sum1 = " + sum1);
        System.out.println("sum2 = " + sum2);
    }
}

多态的实现条件

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

//多态体现：在代码运行时，当传递不同类对象时，会调用对应类中的方法
class Animal1 {
    String name;
    int age;
    public Animal1(String name, int age){
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println(name + "吃饭");
    }
}
class Cat1 extends Animal{
    public Cat1(String name, int age){
        super(name, age);
    }
    public void eat(){
        System.out.println(name+"吃鱼~~~");
    }
}
class Dog1 extends Animal {
    public Dog1(String name, int age){
        super(name, age);
    }
    //与父类中的public void eat()方法重写
    public void eat(){
        System.out.println(name+"吃骨头~~~");
    }
}
public class Test2 {
    // 编译器在编译代码时，并不知道要调用Dog还是Cat中eat的方法
    // 等程序运行起来后，形参animal引用的具体对象确定后，才知道调用那个方法
   // 注意：此处的形参类型必须时父类类型才可以
    public static void eat(Animal animal){
        animal.eat();
    }
    public static void main(String[] args) {
        Cat1 cat = new Cat1("旺财",2);
        Dog1 dog = new Dog1("阿七", 1);
        eat(dog);
        eat(cat);
    }
}

总结:父类引用 引用子类对象，当引用的子类对象不一样的时候，通过这个给父类引用调用父类和在子类重写的方法的时候，此时同一个引用呈现出来了不同的状态，我们把这个思想叫做多态

向上转型和向下转型

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

语法格式：父类类型 对象名 = new 子类类型()
Animal animal = new Cat(“张三”,2);

animal是父类类型，但可以引用一个子类对象，因为是从小范围向大范围的转换。

//使用场景
//1. 直接赋值 
Animal animal1 = new Dog("wangwang",11);
//2. 方法传参
 public static void eat(Animal animal){
        animal.eat();
    }
//3. 方法返回
 public static Animal getAnimal() {
        return new Dog();
}
//向上转型的优点：让代码实现更简单灵活。
//向上转型的缺陷：不能调用到子类特有的方法

//将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的方法，此时：将父类引用再还原为子类对象即可，即向下转换。
class Animal1 {
    String name;
    int age;
    public Animal1(String name, int age){
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println(name + "吃饭");
    }
}
class Cat1 extends Animal{
    public Cat1(String name, int age){
        super(name, age);
    }
    public void eat(){
        System.out.println(name+"吃鱼~~~");
    }
    public void mimi() {
        System.out.println(name+"咪咪叫");
    }
}
class Dog1 extends Animal {
    public Dog1(String name, int age){
        super(name, age);
    }
    //与父类中的public void eat()方法重写
    public void eat(){
        System.out.println(name+"吃骨头~~~");
    }
    public void bark() {
        System.out.println(name+"汪汪汪");
    }
}
public class Test2 {
    public static void main(String[] args) {
        Animal animal = new Dog1("wangcai",1);
//animal本来指向的就是狗，因此将animal还原为狗也是安全的
        Dog1 dog = (Dog1) animal;//强制类型转换为Dog
        dog.bark();
//程序可以通过编程，但运行时抛出异常---因为：animal实际指向的是狗
//现在要强制还原为猫，无法正常还原，运行时抛出:ClassCastException
        //Cat1 cat1 = (Cat1) animal;
        //cat1.mimi();
        
//向下转型用的比较少，而且不安全，万一转换失败，运行时就会抛异常。Java中为了提高向下转型的安全性，引入了 instanceof ，如果该表达式为true，则可以安全转换。
if (animal instanceof Cat) {
            Cat1 cat1 = (Cat1) animal;
            cat1.mimi();
        }
    }
    //instanceof判断其左边对象是否为其右边类的实例，返回的是boolean类型的数据

多态的优缺点

优点:

1. 能够降低代码的 “圈复杂度”, 避免使用大量的 if - else
2. 可扩展能力更强

缺点:

1. 属性没有多态性
   父类引用只能访问父类的方法和属性，而不能访问子类特有的方法和属性。如果需要访问子类特有的方法和属性，就需要进行类型强制转换。
   2.在构造方法中调用重写的方法

class B {
    public B() {
        func();
    }
    public void func() {
        System.out.println("B.func()");
    }
}
class D extends B {
    private int num = 1;
    @Override
    public void func() {
        System.out.println("D.func() " + num);
        //D这个对象没有构造完成，所以num还没有被初始化
    }
}
public class Test2 {
    public static void main(String[] args) {
        D d = new D();
    }
}

• 构造 D 对象的同时, 会调用 B 的构造方法.
• B 的构造方法中调用了 func 方法, 此时会触发动态绑定, 会调用到 D 中的 func
• 此时 D 对象自身还没有构造, 此时 num 处在未初始化的状态, 值为 0
• 所以在构造函数内，尽量避免使用实例方法

总结:用尽量简单的方式使对象进入可工作状态", 尽量不要在构造器中调用方法(如果这个方法被子类重写, 就会触发动态绑定, 但是此时子类对象还没构造完成), 可能会出现一些隐藏的但是又极难发现的问题.