Chain programming, packages, access

1 链式编程

形式参数：
   类：需要的是该类或者该类子类的对象
   抽象类：需要的是该抽象类的普通子类的对象
   接口：需要的是该接口的普通子类对象

返回值类型：
   类：其实返回的是该类或者该类子类的对象
   抽象类：其实返回的是抽象类的子类对象
   接口：其实返回的是该接口的子类对象

abstract class Person {
    
    public abstract void show();
}

class Student extends Person {
    
    String name;

    Student() {
    
    }

    Student(String name) {
    
        this.name = name;
    }

    @Override
    public void show() {
    
        System.out.println("Student.show()");
    }

    public Student method() {
    
        System.out.println("name = " + name);
        // return new Student(); // 情况一：创建了五个Student对象

        return this; // 情况二：仅创建了一个对象,StringBuffer和StringBuilder底层就是这么操作的(只有一个对象).
    }
}

class PersonDemo {
    
    public Person getPerson() {
    
        // return new Person(); // 抽象类不能被实例化
        return new Student();
    }
}

public class Test1 {
    
    public static void main(String[] args) {
    
        /*PersonDemo pd = new PersonDemo(); Person p = pd.getPerson(); // 多态 p.show(); // Student.show()*/

        /*PersonDemo pd = new PersonDemo(); pd.getPerson().show(); // Student.show() 结果同上*/

        // 链式编程
        // new PersonDemo().getPerson().show(); // Student.show()

        Student s = new Student("Henson_z");
        s.method().method().method().method();
        // 情况一运行结果：name = Henson_z, name = null, name = null, name = null
        // 情况二运行结果：name = Henson_z, name = Henson_z, name = Henson_z, name = Henson_z
    }
}

2 包

包：相当于文件夹
	a.作用：
        1. 解决命令冲突问题
		2. 对类进行分类管理
    b.划分：
		1.按功能划分
			add 增
			delete 删
			update 改
			search 查
		2.按模块划分
			student 学生模块
			teacher 老师模块
    c.格式：
        package 包名;
    d.不同包下的类的访问：
        通过包名.类名进行访问.--> 术语：类的全限定名 = 包名.类名
注意事项：
    a.package语句必须是程序的第一条可执行的代码;
    b.package语句在一个.java文件中只能有一个,如果没有package,默认表示无包名.

导包：
    格式：import 包名.类名
    注意事项:
        1.导包需要导入到类这一级; --> import java.util.Scanner
        2.导包可以使用通配符*,比如 import java.util.* 表示导入java.util包下的所有类.
        3.JDK1.5新特性：
            静态导入(导到方法这一级),import static java.util.Arrays.sort,则使用时不需要Arrays.sort(arr),直接使用sort(arr),即不需要指定类名,好像这个方法就定义在我的类中一样.(不推荐)

面试题：package, import, class有没有顺序关系
    有顺序关系,package在最前面,然后到import,最后是class

package：一个.java文件最多只能有一个package语句;
import：一个.java文件可以有多个import语句;
class：一个.java文件可以有多个class,但是public class(主类)最多只能有一个.
    建议：今后一个.java文件中只创建一个class.

import com.cskaoyan.e_package.stu.Student;

import java.util.Arrays;

import static java.util.Arrays.sort; // 静态导入(不推荐)

public class PackageDemo1 {
    
    public static void main(String[] args) {
    
        Student s = new Student(); // 在IDE中,上面自动导包.

        int[] arr = {
    3, 5, 1, 4, 2};
        Arrays.sort(arr); // 没有使用静态导入
        System.out.println(Arrays.toString(arr)); // [1, 2, 3, 4, 5]

        int[] arr1 = {
    3, 5, 1, 4, 2};
        sort(arr1); // 使用静态导入(不推荐),这时候sort()方法就好像定义在PackageDemo1这个类中,不需要指定类名.
        System.out.println(Arrays.toString(arr1)); // [1, 2, 3, 4, 5]
    }
}

3 访问权限

访问权限修饰符:
   a.private: 私有的,本类中才可以访问.
   b.()默认:  本包中才可以访问.
   c.protected: 受保护的, 本包中可以访问,不同包的子类(只能通过子类去访问)也可以访问.
       如People在peo包中,Student在stu包中,Student继承People,在Student中访问People成员时,只能通过Student(子类)对象访问,不能通过People(父类)对象访问.
   d.public: 公共的,整个项目中都可以访问.

                同一个类        同一个包    不同包的子类        不同包的其他类
   private         Y              N            N                   N
   ()              Y              Y            N                   N
   protected       Y              Y            Y(条件)             N
   public          Y              Y            Y                   Y

类及其组成(变量、构造方法、方法)可以使用哪些修饰符？
    修饰符：
        访问权限修饰符：private, (), protected, public
        静态修饰符：static
        不可变修饰符：final
        抽象修饰符：abstract
    a.普通类：可以使用 (), public, final, abstract
    b.变量：可以使用 private, (), protected, public, static, final
    c.构造方法：可以使用 private, (), protected, public
    d.方法：可以使用 private, (), protected, public, static, final, abstract

Demo1和Demo2在demo1包中：

Demo1：

package demo1;

public class Demo1 {
    
    private int a = 10;
    int b = 20;
    protected int c = 30;
    public int d = 40;

    public static void main(String[] args) {
    
        Demo1 demo1 = new Demo1();
        // 在本类中,四种修饰符都可以被访问.
        System.out.println(demo1.a); // 10
        System.out.println(demo1.b); // 20
        System.out.println(demo1.c); // 30
        System.out.println(demo1.d); // 40
    }
}

Demo2:

package demo1;

public class Demo2 {
    
    public static void main(String[] args) {
    
        Demo1 demo1 = new Demo1();
        // 在同一个包中,(), protected, public都能被访问,private修饰的不能被访问.
        // System.out.println(demo1.a);
        System.out.println(demo1.b); // 20
        System.out.println(demo1.c); // 30
        System.out.println(demo1.d); // 40
    }
}

Demo3, Demo4, Demo5 都在demo2包中：

Demo3:

package demo2;

import demo1.Demo1;

public class Demo3 extends Demo1 {
    
    public static void main(String[] args) {
    
        Demo1 demo1 = new Demo1();
        // 不同包中的子类,必须要通过子类对象才可以访问父类protected修饰的成员
        // System.out.println(demo1.a); // 不能访问
        // System.out.println(demo1.b); // 不能访问
        // System.out.println(demo1.c); // 不能访问 // 必须要通过子类对象才可以访问父类protected修饰的成员
        System.out.println(demo1.d); // 40 可以访问

        Demo3 demo3 = new Demo3();
        // System.out.println(demo3.a);
        // System.out.println(demo3.b);
        System.out.println(demo3.c); // 30 // 必须通过子类对象才可以访问不同包中的父类的protected成员
        System.out.println(demo3.d); // 40
    }
}

Demo4:

package demo2;

import demo1.Demo1;

public class Demo4 {
    
    public static void main(String[] args) {
    
        Demo1 demo1 = new Demo1();
        // 不同包中的其他类,只有public修饰的才能被访问.
        // System.out.println(demo1.a);
        // System.out.println(demo1.b);
        // System.out.println(demo1.c); // 没有继承关系,报错.
        System.out.println(demo1.d); // 40
    }
}

Demo5:

package demo2;

public class Demo5 {
    
    // protected可以修饰构造方法
    protected Demo5() {
    
        System.out.println("无参构造方法");
    }

    public static void main(String[] args) {
    
        new Demo5(); // 无参构造方法
    }
}