007Java基础之包、访问修饰符、面向对象的 三大特性

1、包

包的三大作用：
（1）区分相同名字的类
（2）当类很多时，可以很好的管理类
（3）控制访问范围
基本语法

package com.francis;
1、package 关键字 表示打包
2、com.francis 表示包名

注意事项和细节
（1）package指令只能放在类的最上面
（2）一个类只能有一条package指令

2、访问修饰符

java 提供四种访问控制修饰符号，用于控制方法和属性(成员变量)的访问权限（范围）:
（1） 公开级别:用 public 修饰,对外公开
（2）受保护级别:用 protected 修饰,对子类和同一个包中的类公开，即使子类不同包
（3） 默认级别:没有修饰符号,向同一个包的类公开.
（4）) 私有级别:用 private 修饰,只有类本身可以访问,不对外公开.

1、4 种访问修饰符的访问范围

注意事项和细节
（1）访问修饰符可以用来修饰类，类的成员属性，类的成员方法
（2）只有默认和public才能修饰类
（3）成员方法的访问规则与成员属性的规则一样

3、面向对象的三大特征

1、封装

封装解决数据的安全性
封装就是把抽象出的数据（属性）和对数据的操作（方法）封装在一起，数据被保护在内部，程序的其他部分只有通过被授权的操作（方法），才能对数据进行操作

2、封装的好处

（1）隐藏实现的细节
（2）可以对数据进行验证，保证安全合理

3、面向对象编程-封装

（1）将属性进行私有化，private修饰
（2）提供公共的public的set方法，用于对属性判断并赋值
（2）提供公共的public的get方法，用于获取属性的值

2、继承

继承用来解决代码的复用性
继承可以解决代码复用,让我们的编程更加靠近人类思维.当多个类存在相同的属性(变量)和方法时,可以从这些类中
抽象出父类,在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过 extends 来
声明继承父类即可。画出继承的示意图

基本语法

class 子类 extends 父类{
}

（1）子类就会自动拥有父类中定义的成员属性和成员方法
（2）父类又叫超类，基类
（3）子类又叫派生类
注意事项和细节
（1）子类继承了所有的属性和方法，在同包的情况下，非私有的属性和方法可以在子类直接访问, 但是私有属性和方法不能在子类直接访问，即不能通过.的方式去访问，要通过父类提供公共的方法去访问
（2）子类必须调用父类的构造器， 完成父类的初始化
（3） 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用 super 去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过
（4） 如果希望指定去调用父类的某个构造器，则显式的调用一下 : super(参数列表)
（5） super 构造器在使用时，必须放在构造器第一行(super 只能在构造器中使用)
（6） super() 和 this() 都只能放在构造器第一行，因此这两个方法不能共存在一个构造器
（7） java 所有类都是 Object 类的子类, Object 是所有类的基类.
（8） 父类构造器的调用不限于直接父类！将一直往上追溯直到 Object 类(顶级父类)
（9）子类最多只能继承一个父类(指直接继承)，即 java 中是单继承机制。
（10） 不能滥用继承，子类和父类之间必须满足 is-a 的逻辑关系
子类创建的内存布局

/**
 * @author Francis
 * @create 2021-06-25 12:08
 */
public class ExtendsTheory {
    public static void main(String[] args) {
        Son son = new Son();//内存的布局
//?-> 这时请大家注意，要按照查找关系来返回信息
//(1) 首先看子类是否有该属性
//(2) 如果子类有这个属性，并且可以访问，则返回信息
//(3) 如果子类没有这个属性，就看父类有没有这个属性(如果父类有该属性，并且可以访问，就返回信息..)
//(4) 如果父类没有就按照(3)的规则，继续找上级父类，直到 Object... System.out.println(son.name);//返回就是大头儿子
//System.out.println(son.age);//返回的就是 39
//System.out.println(son.getAge());//返回的就是 39
        System.out.println(son.hobby);//返回的就是旅游
    }
}

class GrandPa { //爷类
    String name = "大头爷爷";
   
    String hobby = "旅游";
}
class Father extends GrandPa {//父类
    String name = "大头爸爸";
    private int age = 39;
    public int getAge() {
        return age;
    }
}
class Son extends Father { //子类
    String name = "大头儿子";
}

构造器的执行顺序

/**
 * @author Francis
 * @create 2021-06-25 13:33
 */
public class ExtendsExercise01 {
    public static void main(String[] args) {
        C c = new C();
    }
}
class A {//A 类
    public A() {
        System.out.println("我是 A 类");
    }
}
class B extends A { //B 类,继承 A 类 //main 方法中： C c =new C(); 输出么内容? 3min
    public B() {
        System.out.println("我是 B 类的无参构造");
    }
    public B(String name) {
        System.out.println(name + "我是 B 类的有参构造");
    }
}
class C extends B { //C 类，继承 B 类
    public C() {
        this("hello");
        System.out.println("我是 c 类的无参构造");
    }
    public C(String name) {
        super("hahah");
        System.out.println("我是 c 类的有参构造");
    }
}

super关键字
（1）调用父类的构造器，（分工明确，父类属性由父类初始化，子类属性由子类初始化）
（2）当子类中有和父类中的成员（属性和方法）重名时，为了访问父类的成员，必须通过super，如果没有重名，使用super，this访问的效果四一样的
（3）super的访问不限于直接父类，如果爷爷类有与本类重名的成员，也可以用super去访问爷爷类的成员，如果多个基类中都有同名的成员，使用super访问遵循就近原则，当然也需要遵守访问权限相关的规则。

方法的 重写/覆盖
简单的说，方法的重写（覆盖）就是子类有一个方法，和父类的某个方法的名称，返回类型（严格来说是兼容），参数列表都一样，那么我们就说子类的这个方法覆盖了父类的方法。
注意事项和细节
（1）子类的方法名称，形参列表，要和父类的方法名称，形参列表完全一样。
（2）子类方法的返回类型要和父类方法的返回类型一样，或者是父类返回类型的子类（兼容）。
（3）子类方法不能缩小父类方法的访问权限，及访问修饰符只能扩大，不能缩小。
方法的重载和重写的区别

3、多态

多态解决代码的复用性
基本介绍
方法或对象具有多种形态。是面向对象的第三大特征，多态是建立在封装和继承基础之上的。
（1）方法的多态
方法的重写和重载就体现多态
（2）对象的多态
父类的引用可以指向任何子类的对象
注意事项和细节
（1）一个对象的编译类型和运行类型可以不一致
（2）编译类型在定义对象时就确定了，不能改变
（3）运行类型是可以改变的
（4）编译类型看定义是 = 号的左边，运行类型看 = 号的右边
（5）对象多态的前提：两个对象(类)存在继承关系

1、多态的向上转型

（1）本质：父类的引用，指向子类的对象
（2）语法：父类类型 引用名 = new 子类类型();
（3）特点：编译类型看左边，运行类型看右边，可以调用父类中的所有成员（ 需遵守访问权限），不能调用子类中特有的成员，最终运行结果看子类中的具体实现

2、多态向下转型

（1）语法：子类类型 引用名 = (子类类型) 父类引用;
（2）只能强转父类的引用，不能强转父类的对象
（3）要求父类的引用必须指向的是要强转类型的对象
（4）当向下转型后，可以调用子类类型中的所有成员
属性没有转型的说法，属性的值看编译类型，方法的运行结果看运行类型
这和方法很不一样!
在向下转型时，为了避免转换异常，用instanceOf()来判断对象的运行类型是否为XX类型或者是XX类型的子类型，如果是，返回true，如果不是，返回false。

3、java的动态绑定机制

（1）当调用对象的方法时，该方法会和该对象的内存地址/运行类型绑定
（2）当调用对象的属性时，没有动态绑定机制，哪里声明，哪里调用
子父类都有相同的方法

子类没有对应的方法，方法内部调用的方法

4、多态的应用

（1）动态数组