访问权限控制

一，package

1，package必须是除注释外的第一条程序代码

2，编译目录下的java文件，用javac "java文件路径/java文件"

3，可用javac -d + "类存放路径" + "java文件路径/java文件"(.class文件的集中管理)

4，运行.class文件 java + "类完整路径"

5，类路径必须是classpath所能访问的

二，封装

把数据与方法包装进类中，以及具体实现的隐藏，称封装。

复用类

1，组合

新类由现有类的对象组成

2，继承

由现有类添加新代码

3，多使用组合而非继承

4，final关键字

final使得基本类型数值恒定不变，使得对象引用指定不变

• 空白final

声明为final，却没赋初值。

class Person
{
    public static int count = 0;
    private final int id;
    Person()
    {
        id = count++;
    }
    int getId()
    {
        return id;
    }
}
public class FinalDemo1 
{
    public static void main(String[] args) 
    {   
        Person[] ps = new Person[5];
        for(int i = 0;i < 5;i++)
        {
            ps[i] = new Person();
            System.out.println(ps[i].getId());
        }
    }
}
/*
输出：
0
1
2
3
4
 */

• final参数

意味着在方法中，无法更改该参数

• final方法

锁定方法，禁止继承

• final类

锁定类，禁止继承

多态（Polymorphism）（动态绑定，后期绑定）

1, 表现：向上转型后，能够调用子类本身与父类重名的方法

class Father
{
    void show()
    {
        System.out.println("I am a father");
    }
}
class Son extends Father
{
    void show()
    {
        System.out.println("I am a son");
    }
}
public class PolymorphismDemo1 
{
    public static void whoYouAre(Father f)
    {
        f.show();
    }
    public static void main(String[] args) 
    {
        whoYouAre(new Son());
    }
}
/*
输出
I am a son
*/

2，作用：消除类型之间的耦合关系

3，Java除了static和final方法（private也属于private)之外，其他方法都是后期绑定

4，构造器如果可以要尽可能避免调用方法,不然可能会因为多态产生错误

class Father3
{
    int age = 30;
    Father3()
    {
        System.out.println("Father:before show");
        show();
        System.out.println("Father:after show");
    }
    void show()
    {
        System.out.println("Father is "+age+  " year's old" );
    }
}
class Son3 extends Father3
{
    int age = 12;
    Son3(int age)
    {
        System.out.println("Son:before show");
        this.age = age;
        show();
        System.out.println("Son:after show");
    }
    void show()
    {
        System.out.println("Son is "+age+" year's old" );
    }
}
public class PolymorphismDemo2 
{
    public static void main(String[] args) 
    {
        new Son3(15);
    }
}
/*
输出
Father:before show
Son is 0 year's old //混入了奇怪的东西
Father:after show
Son:before show
Son is 15 year's old
Son:after show
*/ 

5，协变返回值:导出类的覆盖方法可以返回 基类方法返回类型 的导出类。

class Grain
{
    public String toString() 
    {
        return "grain";
    }
}
class Wheat extends Grain
{
    public String toString() 
    {
        return "wheat";
    }
}
class Mill
{
    Grain process()
    {
        return new Grain();
    }
}
class WheatMill extends Mill
{
    Wheat process()
    {
        return new Wheat();
    }
}
public class PolymorphismDemo3 
{
    public static void main(String[] args) 
    {
        WheatMill wm = new WheatMill();
        System.out.println(wm.process());
    }
}
/*
输出
wheat
*/

结束