• 面向物件程式設計（簡稱OOP）是當今主流的程式設計典型。
• 面向物件的程式是由物件組成的，每個物件
• Java是一種面向物件的語言。由於具有面向物件特性的語言，Java支援以下基本概念：

多型性 繼承 封裝 抽象化 類 物件 例項 方法 訊息解析

物件

物件：物件是類的例項，有狀態和行為。
類：類是一個模板，它描述一類物件的行為和狀態。

物件的初始化方法

• 1、提供一系列的 get 、set 方法

class Person {
    private int age;
    private String name;
    private
 
 String sex;
 public String getName(){
          return name;
          }
          public setName(String name){
          this.name = name;
           public String getSex(){
          return sex;
          }
          public setSex(String sex){
          this.sex = sex;

           public String getAge
 
(){
          return age;
          }
          public setName(int age){
          this.age = age;
          public class ObjectInit(){
          public static void main(String[]  args){
          Person person = new Person();
          person.setAge(25);
          person.setName("liming");
          person.
 
setSex(man);
          System.out.println(person.getAge());
          System.out.println(person.getName());
          System.out.println(person.getSex());
          }
          }

• 2、通過合適的建構函式進行初始化
• （1）物件的建立分為那幾步
• a.首先為物件分配記憶體
• b.呼叫合適的建構函式
  1、

class Person {
   private int age;
   private String name;
   private String sex;

2、帶引數的建構函式

   class Person {
    private int age;
    private String name;
    private String sex;
  public Person1(String name,String sex ,int age) {
        this.sex = sex;
        this.name = name;
        this.age = age
    }

3、

class Person {
    private int age;
    private String name;
    private String sex;
    public person1()[
    System.out.println("");
    }

• 在一個類中定義另一個類，這個類就叫做內部類或內建類，也稱為巢狀類，包含內部類的類稱為外部類。
• 與一般的類相同，內部類可以具有資料成員和成員方法；通過建立內部類的物件，可以存取其資料成員和呼叫其成員方法。

public class Group(){
int count;
public class Student{
String name;
public void Output(){
System.t.println(this.name + "QQ")
}}}

• 內部類也可以分為static和非static，前者稱為靜態內部類，後者稱為成員類（非靜態內部類），內部類也可以在某個方法中定義，這種內部類稱為區域性內部類。
• 另一種匿名內部類則是建立物件的同時定義類的實現，但是未規定類名。

public class OuterOne{
private int x = 3;
InnerOne ino = new InnerOne(); //外部類有一個屬性指向建立的內部類的物件
public class InnerOne{      //內部類
private int y = 5;
public void innerMethod(){
System.out.println(" y is " + y);
} public void innerMethod2(){
System.out.println(" x2 is " + x); //訪問外部類變數
}
}   //內部類結束
publicript
public class Group(){
int count;
public class Student{
String name;
public void Output(){
System.t.println(this.name + "QQ")
}}}

• 內部類是一個編譯時的概念，編譯成功後就會成為完全不同的兩類。
• 內部類 的命名除了不能與自己的外部類同名外，不必擔心與其他類名衝突，因為其真實名加了外部類名作為字首。
• 在內部類中可以訪問外部類成員，與外部類成員一樣，在內部類中可以使用訪問控制符 public、protected、private修飾。
• 在外部類中訪問內部類一般通過在外部類的成員定義中建立內部類物件。
• InnerOne ino = new InnerOne();
• 在內部類中使用this ,this 指當前類的物件，要訪問外部類的當前物件必須加上外部類名作字首。

javascript 
      外部類：OuterOne       
      內部類：InnerOne     
      用OuterOne.this代表外部類的this物件。

靜態塊初始化

靜態塊初始化======》例項程式碼塊初始化========》建構函式

 static{     
   }

例項塊初始化

public static void main(String[] args) {
    Person person = new Person();//例項化出來一個物件
    person.age = 100;
    person.name = "caocao";
    person.sex = "man";
    System.out.println("===============");
    System.out.println(person);
    Person person1 = new Person();
    person.age = 888;
    person.name = "liubei";
    person.sex = "man";
    System.out.println("===============");
    Person person2 = new Person();
    person.age = 100;
    person.name = "caocao";
    person.sex = "man";
}

• 靜態程式碼塊只能初始化一次
• 內部類分為四種： 例項內部類、靜態內部類、區域性內部類、匿名內部類

例項內部類

class OuterClass2 {
    public int data1;
    private int data2;
    private static int data3;

    {
        data1 = 999;
        data2 = 888;
        data3 = 777;
    }

    public OuterClass2() {
        System.out.println("OuterClass() init");
    }

    public void test1() {
        System.out.println("OuterClass().test1()");
    }
}

靜態內部類

• 定義為static的內部類稱為靜態內部類。靜態內部類沒有指向外部的引用。
• 非靜態內部類不能宣告靜態成員，只有靜態內部類才能宣告靜態成靜態內部類員。
• 靜態內部類不能引用外部類成員或者其他內部類成員。

public class StaticTest{
public static class person{
   private int age;
   private String name;
   private String sex;
   static count = 0;
   Person(String n, String m, int a){
    age = a;
   name = n;
   sex = m;
   count++;
   }
   public void display(){
   System.out.println("count=" + count+"\t"+age+"\t"+name+"\t"+sex);
   }
   }
   public static void main(String[] args){
   staticTest.Preson person1 = new StaticTest.Person(16,"Limei","Women");
   person1.display();
   staticTest.Preson person2 = new StaticTest.Person(18,"Liming","man");
    person2.display();
    }
    }

匿名內部類

• 語法規則

new interfacename(){

}
或
new superclassname(){

}

public class TestInnerClassDemo2 {

    public static void test(OuterClass3 out3) {
        out3.sayHello();
    }

    public static void main(String[] args) {
        //第一種
        new OuterClass3(){
            public void sayHello() {
                System.out.println("main : hello");
            }
        }.sayHello();

        test(new OuterClass3());
    }

• 匿名內部類沒有名字，所以它沒有構造方法（但是如果這個匿名內部類繼承了一個只含有帶引數構造方法的父類，建立他的時候就必須帶上這些引數，並在實現的過程中使用super關鍵字呼叫想應的內容）。