访问权限控制

一.成员访问权限

1. public–公有
   成员变量，成员方法，类—-可以被任何类访问（不管是不是在同一个包中）；

2. protected–保护
   成员变量，成员方法—-只能被同包，同目录下，该类自身，子类访问；

3. 无限定词–包可访问类型
   成员变量，成员方法，类—-只能被类自身以及同一个包或目录下的类访问；

4. private–私有
   成员变量，成员方法—-只能被类自身访问；

权限总结
一个类自身可访问该类的任何成员方法和成员变量；
同一个包类仅不能访问private修饰的私有成员；
不同包的非子类只能访问该类的public成员；
子类可拥有父类所有的非私有成员方法和成员变量；

使用总结
一个对象所有的成员变量如有可能应当是私有的，至少应是保护类型的；
类的构造方法至少应该是公有的，或包可访问的；

二，静态成员变量和静态成员方法

1. static修饰符
   与public，private，protected等一起做修饰作用；

2. 类变量和类方法
   static修饰成员变量叫做类变量，也叫静态成员变量；
   类变量可被该类所有的实例对象共享；
   一个非私有的静态变量可以直接通过类名访问，也可以通过实例对象名访问；
   没有static限定的是实例变量，每个对象都有自己的实例变量的拷贝，但不管多少对象被实例化，一个静态成员变量仅存在一个版本；

3. 类方法
   static修饰的成员方法叫做类方法或者静态成员方法；
   静态成员方法在所有实例对象间是共享的，不需要实例化对象就可以调用，即可以直接使用类名访问；
   静态成员方法只能访问静态成员变量，输入的参数，以及该类中的其他静态成员方法；

4. static使用总结
   运行过程中仅依赖于输入参数的方法应标记为静态成员方法；
   类变量通常是定义常数，即使用限定语public static final，这样该类变量就是安全的，因为改变量一旦经过初始化就不能改变，如PI；

复用类

7.1 组合语法

1. 对于非基本类型的对象,必须将其引用置于新的类中,但可以直接定义基本类型数据.

package cn.itcast.zhuofai728.demo1;
class WaterSource{
    private String s;
    WaterSource(){
        System.out.println("WaterSource");
        s = "Constructed";
    }
    public String toString(){return s;}
}
public class SprinklerSystem {
    private String ;
    private WaterSource source = new WaterSource();
    public String toString(){
        return "source = " + source;//注意此段代码如果直接用return source;是错误的只有前面用""+source此时默认使用""+source.toString();也就是刚刚重写toString方法
    }

    public static void main(String[] args) {
        SprinklerSystem sprinklers = new SprinklerSystem();
        System.out.println(sprinklers);
    }
}

1. 初始化引用的四种方式
   1. 在定义对象的地方.
   2. 在类的构造器中.
   3. 就在正要使用这些对象之前,对这种方式称为惰性初始化.
   4. 使用实例初始化.

7.2 继承语法

1. Java用super关键字表示超类的意思,当前类就是从超类继承来的.
2. 如果没有默认的基类构造器,或者想调用一个带参数的基类构造器,就必须用关键字super显示的编写调用基类构造器的语句,并且配以适当的参数列表.
3. 调用构造器必须是你在导出类构造器中要做的第一件事.

7.3 代理

//太空船需要一个控制板
public class SpaceShipControls {
    void up(int velocity){}
    void down(int velocity){}
    void left(int velocity){}
    void right(int velocity){}
    void forward(int velocity){}
    void back(int velocity){}
    void turboBoost(){}
}
//构造太空船的一种方式是使用继承
public class SpaceShip extends SpaceShipControls {
    private String name;
    public SpaceShip(String name){this.name = name;}
    public String toString(){return name;}
    public static void main(String[] args){
        SpaceShip protector = new SpaceShip("NSEA Protector");
        protector.forward(100);
    }
}
//可以看到下面的方法是如何传递给了底层的controls对象,而其接口由此也就与使用继承得到的接口相同了.但是我们使用代理时可以拥有更多的控制力.
//因为我们可以选择只提供在成员对象中的方法的某个子集即提供特定的几个方法而不是全部
public class SpaceShipDelgation {
    private String name;
    private SpaceShipControls controls =
            new SpaceShipControls();
    public SpaceShipDelgation(String name){
        this.name = name;
    }
    //Delegated methods:
    public void back(int velocity){
        controls.down(velocity);
    }
    public void forward(int velocity){
        controls.forward(velocity);
    }
    public void left(int velocity){
        controls.left(velocity);
    }
    public void right(int velocity){
        controls.right(velocity);
    }
    public void turboBoost(){
        controls.turboBoost();
    }
    public void up(int velocity){
        controls.up(velocity);
    }

    public static void main(String[] args) {
        SpaceShipDelgation protector = new SpaceShipDelgation("NSEA Protector");
        protector.forward(100);
    }
}

7.4结合使用组合和继承

1. java中没有C++析构函数的概念.析构函数是一中在对象被销毁时可以被自动调用的函数.其原因可能是因为在Java中,我们的习惯只是忘掉而不是销毁对象,并且让垃圾回收器在必要时释放其内存.
2. 可以将清理动作置于finally子句之中,以预防异常的出现.
3. 首先,执行类的所有特定的清理动作,其顺序同生成<b>顺序相反</b>(<em><b>通常这就要求基类元素仍旧存活</b></em>)
4. 如果需要进行清理,最好是编写自己的清理方法,不要使用finalize();
5. 可以重载基类方法但是不要覆写.

class Homer{
    char doh(char c){
        print("doh(char)");
        return 'd';
    }
    float doh(float f){
        print("doh(float)");
        return 1.0f;
    }
}
class Milhouse{}
class Bart extends Homer{
    // void doh(Milhouse m){
    //     print("doh(Milhouse)");
    // }//这是原本对的程序
    void doh(char m){

    }//这样会产生如下错误Error:demo7_4.Bart中的doh(char)无法覆盖demo7_4.Homer中的doh(char)返回类型void与char不兼容

}

1. "is-a"(是一个)的关系使用继承来表达的,而"has-a"(有一个)的关系则是用组合来表达的.

//感觉自己还是不会组合关系所以把代码又拷贝下来了.
class Engine{//引擎走向
    public void start(){}
    public void rev(){}
    public void stop(){}
    public void service(){}
}
class Wheel{//轮子
    public void inflate(int psi){}
}
class Window{//窗户
    public void rollup(){}
    public void rolldown(){}
}
class Door{//门
    public Window window = new Window();
    public void open(){}
    public void close(){}
}
public class Car {//它们共同组成一个车子
    //所以就创建了一个engine对象四个轮子对象还有两个门对象left和right
    //把这几个组成car的class当作基本类型来声明定义直接用
    public Engine engine  = new Engine();
    public Wheel [] wheel = new Wheel[4];
    public Door
    left = new Door(),
    right = new Door();//2-door
    public Car(){
        for (int i = 0; i < 4; i++) {
            wheel[i]  = new Wheel();
        }
    }

    public static void main(String[] args) {
        Car car = new Car();
        car.left.window.rollup();
        car.wheel[0].inflate(72);
        car.engine.service();
    }
}