Java基礎之類與物件、單例模式、繼承

Java類別和物件

一般的類別只能是public或default的，若是public的，類別名稱必須和檔案名稱一樣。一般在一個文件只寫一個類，故這個類一般是加上public。

內部類別還可以是private和protected，一般私有化（private），因為只有目前這個類別才需要。這樣只有它的外部類別可以直接存取。所以裡面的資料也無所謂是public還是private或default的。

public class Out {private int d = 10;public int add() {      // 外部类不能直接访问内部类的数据，除非new出内部类对象,如下  // Out.In abc = new Out().new In();a = 3; // falseb = 5; // false}  // 内部类private class In {private int a = 100;int b;public int c;public void add() {
            System.out.println(d); // true, 内部类却可以直接访问外部类的数据}
    }public static void main(String[] args) {
        Out bb = new Out();
        Out.In abc = new Out().new In();
        bb.d = 20; // 本类可以直接访问private，一般不这样，而是写个set函数，搭配get函数System.out.println(aa.a); // 100System.out.println(bb.d); // 被修改为20}
}

• 匿名物件

#

new Abc().run(); // 调用一次后这个对象就销毁new Abc().run(); // 这是另外一个Abc对象了

• ##關於private

• private變數：封裝數據，只給使用者看方法。例如private String name不能隨修改，但提供setName()、getName()方法可調用，實作資料的封裝，更安全。

• private方法：不用使用者呼叫的函數，完成一些內部實作的細節，就可以定義成private。例如選擇排序演算法寫成一個方法，裡面有交換兩個資料的過程，封裝成函數。這個函數不需要給使用者操作（使用者只要用一個sort()就行），這個swap()就定義成private的。

單例設計模式

可以保證一個類別在記憶體中的物件唯一性，需對過個程式使用相同設定資訊物件時，就需要保證對象的唯一性，這時就需要

單例。

工具類別中，未使用（存取）物件成員數據，則可不用建立物件。為了防止建立對象，可以將建構函式定義為

private。

如何保證物件的唯一性？

1. 不允許其他程式用new建立該類別對象，建構函式設為private

2. 在該類別建立一個唯一的類別實例

3. 對外提供一個方法使其他程式可以取得到這個唯一物件

#單例設計步驟

1. 私有化（private）該類別的建構子

2. 透過new在本類別中匯總穿件一個本類別物件

3. 定義一個puiblic方法，將2中建立的物件傳回

#

// 饿汉式--不管用不用得到，先new出一个再说public class SingleDemo {// private不能将这个实例暴露出去，只能通过getInstance()获取，另为何是static？private static SingleDemo s = new SingleDemo();private SingleDemo() {}// 供外界调用来获取这个对象public static SingleDemo getInstance() {return s;
    }  // 只有本类中可以new对象并调用addpublic void add() {
        System.out.println("danli");
    }public static void main(String[] args) {      // 本类可以newSingleDemo a = new SingleDemo();
        a.add();
    }
}public class Test {public static void main(String[] args) {      // fasle, 其他类中若用到这个单例，不能newSingleDemo aa = new SingleDemo();      // true  SingleDemo aa = SingleDemo.getInstance();
    }
}

// 另外一种单例设计模式--懒汉模式--用到了才new，延时加载public class SingleDemo {// 先设为空private static SingleDemo s;private SingleDemo() {}// 供外界调用来获取这个对象public static SingleDemo getInstance() {      if (s == null)
        s = new SingleDemo();return s;
    }

懶漢模式

##

package Chap1;public class Fu {  // 父类的成员是私有的，子类继承过去了也不能直接访问
  private int age;private String name;public Fu(int age, String name) {this.age = age;this.name = name;
    }public int getAge() {return age;
    }public void setAge(int age) {this.age = age;
    }public String getName() {return name;
    }public void setName(String name) {this.name = name;
    }
}class Zi extends Fu {  // 特有的job，父不能访问private String job;Zi(int age, String name, String job) {super(age, name);this.job = job;
    }public String getJob() {return job;
    }  public static void main(String[] args) {
        Zi aa = new Zi(23, "Zi","Study");
        Fu bb = new Fu(55, "Fu");      // 改变子类不会影响父类aa.setAge(24);
        aa.setName("zi");      // zi 24 Study  // Fu 55System.out.println(aa.getName()+" "+aa.getAge() + " " + aa.getJob());
        System.out.println(bb.getName()+" "+bb.getAge());

    }
}

Q：為何成員變數是static，方法也是static？

A：因為在其他類別中，不允許new出新對象，故不能呼叫getInstance()，如果我們設為

靜態方法

，就可以透過Single.getInstance ()來取得而無需new對象，又靜態方法裡的資料也必須是static的。故這個SingleDemo物件也必須是static的。 Q：餓漢模式和懶漢模式的差別？

A：

懶漢模式
是延時載入的，用到了才new；多執行緒時不能保證物件的唯一性，是執行緒不安全的。 餓漢模式是隨著類別的加載，就new出這個對象，不管用不用得上，是線程安全的。 繼承

Java一般是

單繼承

，不能直接多繼承--> 因為多個父類別可能有相同的成員，呼叫會導致二義性。 但是可以

多層繼承

，如A --> B -->Ｃ--> D，可以表示A繼承自B，而B繼承自C，以此類推。

本類別成員和局部變數之間用
• this

  區分

#子類別、父類別的成員同名時用
• super

  區分

衍生類別也不能存取基底類別的private成員，但確實是繼承過來了，只是不能存取而已，可以呼叫父類別的
• set、get

  函數來操作子類別的private成員，對父類別沒影響。

若成員是protected等權限較高的，則不用
• set、get

  就可直接存取該成員。

父類別與子類別的該成員是相互獨立的，子類別改變它自己的成員，父類別保持原樣。

class Fu {  // 构造函数
  Fu() {
    System.out.println("father");
  }  // 带参的构造函数
   public Fu(int age, String name) {this.age = age;this.name = name;
    }
}class Zi extends Fu {  
  Zi() {private String job;// super() 会打印“father”// 无参数时是默认构造器，这句super()可以不写。父类的构造函数默认执行，先执行// 
  }  
  Zi(int age, String name, String job) {// 若不写，会默认调用无参的super()打印fathersuper(age, name);this.job = job;
    }
}

子類別隱含執行super()，new一個子物件時，先呼叫父類別的建構函數，再執行子類別的建構函數。
預設的建構子是無參的，
• 有參數的建構子會覆寫無參的

  。這時候需要明確使用super(args)，且必須放在第一行，若不明確寫super，則執行預設的super()，即無參的父類別建構子。

package Test;// 先打印9// 再打印100public class Demo {private int age = 9;
    {
        System.out.println(age);
    }Demo(int age) {this.age = age;
    }public static void main(String[] args) {
        Demo aa = new Demo(100);
        System.out.println(aa.age);
    }
}

• 类是public，构造函数也是public的。他们的修饰符是对应的。

一个对象的实例化过程

Person p = new Person();

1. JVM读取Person.class文件，加载进内存；若有父类，会先加载父类。

2. 在堆内存中开辟空间，分配地址。

3. 在对象空间中，对对象的属性进行默认初始化，如int age = 0; String name = null;

4. 显示初始化，如private int age = 9。若是子类，则会先调用父类的构造器。

5. （子）类的 构造函数进行特定的初始化。如下程序中age变成100。

6. 初始化后，将地址传递给引用变量。Person p <-- new Person();

package Test;// 先打印9// 再打印100public class Demo {private int age = 9;
    {
        System.out.println(age);
    }Demo(int age) {this.age = age;
    }public static void main(String[] args) {
        Demo aa = new Demo(100);
        System.out.println(aa.age);
    }
}

以上是Java基礎之類與物件、單例模式、繼承的詳細內容。更多資訊請關注PHP中文網其他相關文章！