final關鍵字

final關鍵字概念

* A: 概述
    繼承的出現提高了代碼的復用性，並方便開發。但隨之也有問題，有些類在描述完之後，不想被繼承，
    或者有些類中的部分方法功能是固定的，不想讓子類重寫。可是當子類繼承了這些特殊類之後，
    就可以對其中的方法進行重寫，那怎麽解決呢？
    要解決上述的這些問題，需要使用到一個關鍵字final，final的意思為最終，不可變。
    final是個修飾符，它可以用來修飾類，類的成員，以及局部變量。

final修飾類義

* A: final 修飾類
    final修飾類不可以被繼承，但是可以繼承其他類。
* B: 案例
    class Yy {}
    final class Fu extends Yy{} //可以繼承Yy類
    class Zi extends Fu{} //不能繼承Fu類
 

?
?

final修飾方法

* A: final修飾方法
    final修飾的方法不可以被覆蓋,但父類中沒有被final修飾方法，子類覆蓋後可以加final。
* B: 案例 
    class Fu {
        // final修飾的方法，不可以被覆蓋，但可以繼承使用
        public final void method1(){}
        public void method2(){}
    }
    class Zi extends Fu {
        //重寫method2方法
        public final void method2(){}
    }
 

final修飾局部變量

* A:修飾基本數據類型變量
    final修飾的變量稱為常量，這些變量只能賦值一次
* B:案例1
    final int i = 20;
    i = 30; //賦值報錯，final修飾的變量只能賦值一次
* C: 修飾引用數據類型
    引用類型的變量值為對象地址值，地址值不能更改，但是地址內的對象屬性值可以修改
* D: 修飾引用數據類型
    final Person p = new Person();
    Person p2 = new Person();
    p = p2; //final修飾的變量p，所記錄的地址值不能改變
    p.name = "小明";//可以更改p對象中name屬性值
    p不能為別的對象，而p對象中的name或age屬性值可更改。
 

final修飾成員變量

* A: 修飾成員變量
    修飾成員變量，需要在創建對象前賦值，否則報錯。(當沒有顯式賦值時，多個構造方法的均需要為其賦值。)

* B: 案例
    class Demo {
        //直接賦值
        final int m = 100;
        //final修飾的成員變量，需要在創建對象前賦值，否則報錯。
        final int n; 
        public Demo(){
            //可以在創建對象時所調用的構造方法中，為變量n賦值
            n = 2016;
        }
    }

static關鍵字

static的概念

* A：概念
    當在定義類的時候，類中都會有相應的屬性和方法。而屬性和方法都是通過創建本類對象調用的。
    當在調用對象的某個方法時，這個方法沒有訪問到對象的特有數據時，方法創建這個對象有些多余。
    可是不創建對象，方法又調用不了，這時就會想，那麽我們能不能不創建對象，就可以調用方法呢？
    可以的，我們可以通過static關鍵字來實現。static它是靜態修飾符，一般用來修飾類中的成員。

static修飾的對象特有數據

* A：特點1:
    被static修飾的成員變量屬於類，不屬於這個類的某個對象。
    （也就是說，多個對象在訪問或修改static修飾的成員變量時，其中一個對象將static成員變量值進行了修改，
    其他對象中的static成員變量值跟著改變，即多個對象共享同一個static成員變量）
* B: 代碼演示
    class Demo {
        public static int num = 100;
    }
    
    class Test {
        public static void main(String[] args) {
            Demo d1 = new Demo();
            Demo d2 = new Demo();
            d1.num = 200;
            System.out.println(d1.num); //結果為200
            System.out.println(d2.num); //結果為200
        }
    }

?

static的內存圖

?

static註意事項_靜態不能直接調用非靜態

* A: 註意事項?  
    被static修飾的成員可以並且建議通過類名直接訪問。
        
* B: 訪問靜態成員的格式：
    類名.靜態成員變量名
    類名.靜態成員方法名(參數)
    對象名.靜態成員變量名             ------不建議使用該方式，會出現警告
    對象名.靜態成員方法名(參數)     ------不建議使用該方式，會出現警告
        
* C: 代碼演示
    class Demo {
        //靜態成員變量
        public static int num = 100;
        //靜態方法
        public static void method(){
            System.out.println("靜態方法");
        }
    }
    class Test {
        public static void main(String[] args) {
            System.out.println(Demo.num);
            Demo.method();
        }
    }

?

static靜態的使用場景

* A: 使用場景
    static可以修飾成員變量和成員方法。    
    什麽時候使用static修飾成員變量？
        加static修飾成員的時候，這個成員會被類的所有對象所共享。一般我們把共性數據定義為靜態的變量
    什麽時候使用static修飾成員方法？
        靜態的方法只能訪問靜態的成員，如果靜態方法中引用到了靜態的其他成員，那麽這個方法需要聲明為靜態的方法。

對象中的靜態調用

* A: 對象的靜態調用
    在多態中，非靜態編譯看父類，運行看子類，父類沒有編譯失敗。
    但多態中的靜態方法,編譯看父類,運行仍然看父類。因為靜態和對象沒有關系，屬於靜態綁定。

* B: 舉例
    public class Test{
        public static void main(String[] args){
            Fu f = new Zi();
            f.show();   //父類的引用和父類的方法綁定,和對象無關,不會在運行時動態的執行子類特有的方法。
        }
    }

定義靜態常量

* A: 靜態常量
    開發中，我們想在類中定義一個靜態常量，通常使用public static final修飾的變量來完成定義。
    此時變量名用全部大寫，多個單詞使用下劃線連接。
* B: 定義格式：
    public static final 數據類型 變量名 = 值;
    
* C: 如下演示：
    class Company {
        public static final String COMPANY_NAME = "傳智播客";
        public static void method(){
            System.out.println("一個靜態方法");
        }
    }

    當我們想使用類的靜態成員時，不需要創建對象，直接使用類名來訪問即可。
    System.out.println(Company.COMPANY_NAME); //打印傳智播客
    Company.method(); // 調用一個靜態方法

* D: 註意：
    接口中的每個成員變量都默認使用public static final修飾。
    所有接口中的成員變量已是靜態常量，由於接口沒有構造方法，所以必須顯示賦值。可以直接用接口名訪問。
    interface Inter {
        public static final int COUNT = 100;
    }
    訪問接口中的靜態變量
    Inter.COUNT

?

匿名對象

* A:匿名對象的概述
    * 匿名對象是指創建對象時，只有創建對象的語句，卻沒有把對象地址值賦值給某個變量。
* B:案例
    public class Person{
        public void eat(){
            System.out.println();
    }
    }

    創建一個普通對象
    Person p = new Person();
    創建一個匿名對象
    new Person();

* C: 匿名對象的特點
    a:創建匿名對象直接使用，沒有變量名。
        new Person().eat()  //eat方法被一個沒有名字的Person對象調用了。

    b:匿名對象在沒有指定其引用變量時，只能使用一次。
        new Person().eat(); 創建一個匿名對象，調用eat方法
        new Person().eat(); 想再次調用eat方法，重新創建了一個匿名對象
        
    c:匿名對象可以作為方法接收的參數、方法返回值使用
        class Demo {
            public static Person getPerson(){
                //普通方式
                //Person p = new Person();  
                //return p;
                
                //匿名對象作為方法返回值
                return new Person(); 
            }
            
            public static void method(Person p){}
        }

        class Test {
            public static void main(String[] args) {
                //調用getPerson方法，得到一個Person對象
                Person person = Demo.getPerson();
                
                //調用method方法
                Demo.method(person);
                //匿名對象作為方法接收的參數
                Demo.method(new Person());
            }
        }

?

內部類

* A: 內部類的概述
    將類寫在其他類的內部，可以寫在其他類的成員位置和局部位置，這時寫在其他類內部的類就稱為內部類。
    其他類也稱為外部類。
* B: 什麽時候使用內部類
    在描述事物時，若一個事物內部還包含其他可能包含的事物，比如在描述汽車時，汽車中還包含這發動機，
    這時發動機就可以使用內部類來描述。
    class 汽車 { //外部類
        class 發動機 { //內部類
        }
    }
* C: 內部類的分類
    內部類分為成員內部類與局部內部類。
    我們定義內部類時，就是一個正常定義類的過程，同樣包含各種修飾符、繼承與實現關系等。
    在內部類中可以直接訪問外部類的所有成員。

成員內部類的調用格式

* A: 格式
    成員內部類，定義在外部類中的成員位置。與類中的成員變量相似，可通過外部類對象進行訪問
* B: 定義格式
    class 外部類 { 
        修飾符 class 內部類 {
            //其他代碼
        }
    }

* C: 訪問方式
    外部類名.內部類名 變量名 = new 外部類名().new 內部類名();

* D: 成員內部類代碼演示
    class Body {//外部類，身體
         private boolean life= true; //生命狀態
         public class Heart { //內部類，心臟
             public void jump() {
                 System.out.println("心臟噗通噗通的跳")
                    System.out.println("生命狀態" + life); //訪問外部類成員變量
            }
        }
    }

    訪問內部類
    public static void main(String[] args) {
        //創建內部類對象
        Body.Heart bh = new Body().new Heart();
        //調用內部類中的方法
        bh.jump();
    }

?

成員內部類的同名變量調用

* A: 代碼實現
    public class Outer {
        int i  = 1;
        class Inner {
            int i  = 2;
            public void inner(){
                int i = 3;
                System.out.println(Outer.this.i);
            }
        }
    }

?

局部內部類

* A 局部內部類，定義在外部類方法中的局部位置。與訪問方法中的局部變量相似，可通過調用方法進行訪問.
* B 定義格式
    class 外部類 { 
        修飾符 返回值類型 方法名(參數) {
            class 內部類 {
                //其他代碼
            }
        }
    }
* C 訪問方式
    在外部類方法中，創建內部類對象，進行訪問

* D 局部內部類代碼演示
    定義類
    class Party {//外部類，聚會
        public void puffBall(){// 吹氣球方法
            class Ball {// 內部類，氣球
                  public void puff(){
                    System.out.println("氣球膨脹了");
                  }
            }
            //創建內部類對象，調用puff方法
            new Ball().puff();
        }
    }
    訪問內部類
    public static void main(String[] args) {    
        //創建外部類對象
        Party p = new Party();
        //調用外部類中的puffBall方法
        p.puffBall();
    }

匿名內部類

 * A: 概述
 內部類是為了應對更為復雜的類間關系。查看源代碼中會涉及到，而在日常業務中很難遇到，這裏不做贅述。
 最常用到的內部類就是匿名內部類，它是局部內部類的一種。
 定義的匿名內部類有兩個含義：
 臨時定義某一指定類型的子類
 定義後即刻創建剛剛定義的這個子類的對象

* B: 本質
 匿名內部類的本質是一個實現了接口或繼承了某個類的子類匿名對象.
 
* C: 案例
public interface Smoking {
    public abstract void smoking();
    }
    /*
     *  實現類,實現接口 重寫接口抽象方法,創建實現類對象
     *  class XXX implements Smoking{
     *      public void smoking(){
     *      
     *      }
     *  }
     *  XXX x = new XXX();
     *  x.smoking(); 
     *  Smoking s = new XXX();
     *  s.smoking();
     *  
     *  匿名內部類,簡化問題:  定義實現類,重寫方法,建立實現類對象,合為一步完成
     */

測試類:
public class Test {
    public static void main(String[] args) {
        //使用匿名內部類
        /*
         *  定義實現類,重寫方法,創建實現類對象,一步搞定
         *  格式:
         *    new 接口或者父類(){
         *       重寫抽象方法
         *    };
         *    從 new開始,到分號結束
         *    創建了接口的實現類的對象
         */
        new Smoking(){
            public void smoking(){
                System.out.println("人在吸煙");
            }
        }.smoking();
    }
}

匿名內部類_2

 * A: 匿名內部類案例演示
    public abstract class Animal {
        public abstract void eat();
        public abstract void sleep();
    }

測試代碼
/*
 *    new Animal(){
            public void eat(){
                System.out.println("在吃飯");
            } 
            public void sleep(){
                System.out.println("在睡覺");
            }
         };
    以上代碼,就是Animal的子類的對象
    多態性, 父類引用 = 子類的對象

 */
public class Test2 {
    public static void main(String[] args) {
        Animal a= new Animal(){
            public void eat(){
                System.out.println("在吃飯");
            } 
            public void sleep(){
                System.out.println("在睡覺");
            }
         };
         a.eat();
         a.sleep();
    }
}

包

包的概念

 * A: 概念
    java的包，其實就是我們電腦系統中的文件夾，包裏存放的是類文件。
    當類文件很多的時候，通常我們會采用多個包進行存放管理他們，這種方式稱為分包管理。
    在項目中，我們將相同功能的類放到一個包中，方便管理。並且日常項目的分工也是以包作為邊界。
    類中聲明的包必須與實際class文件所在的文件夾情況相一致，即類聲明在a包下，則生成的.class文件必須在a文件夾下，否則，程序運行時會找不到類。

* B 聲明格式
    通常使用公司網址反寫，可以有多層包，包名采用全部小寫字母，多層包之間用”.”連接
        類中包的聲明格式： 
    package 包名.包名.包名…;
        如：黑馬程序員網址itheima.com那麽網址反寫就為com.itheima
            傳智播客 itcast.cn  那麽網址反寫就為 cn.itcast
        註意：聲明包的語句，必須寫在程序有效代碼的第一行（註釋不算）
    代碼演示：
    package cn.itcast; //包的聲明，必須在有效代碼的第一行
    
    import java.util.Scanner;
    import java.util.Random;

    public class Demo {}
    
* C: 包的訪問
    在訪問類時，為了能夠找到該類，必須使用含有包名的類全名（包名.類名）。
    包名.包名….類名
    如： java.util.Scanner
         java.util.Random
        cn.itcast.Demo
    帶有包的類，創建對象格式：包名.類名 變量名 = new包名.類名();
         cn.itcast.Demo d = new cn.itcast.Demo();
        前提：包的訪問與訪問權限密切相關，這裏以一般情況來說，即類用public修飾的情況。

        類的簡化訪問
    當我們要使用一個類時，這個類與當前程序在同一個包中（即同一個文件夾中），或者這個類是java.lang包中的類時通常可以省略掉包名，直接使用該類。
    如：cn.itcast包中有兩個類，PersonTest類，與Person類。我們在PersonTest類中，訪問Person類時，由於是同一個包下，訪問時可以省略包名，即直接通過類名訪問 Person。
    類名 變量名 = new類名();
    Person p = new Person();

        當我們要使用的類，與當前程序不在同一個包中（即不同文件夾中），要訪問的類必須用public修飾才可訪問。
    package cn.itcst02;
    public class Person {}

?

導入包

* A:導入包
    我們每次使用類時，都需要寫很長的包名。很麻煩，我們可以通過import導包的方式來簡化。
    可以通過導包的方式使用該類，可以避免使用全類名編寫（即，包類.類名）。
    導包的格式：
    import 包名.類名;

        當程序導入指定的包後，使用類時，就可以簡化了。演示如下
    //導入包前的方式
    //創建對象
    java.util.Random r1 = new java.util.Random();
    java.util.Random r2 = new java.util.Random();
    java.util.Scanner sc1 = new java.util.Scanner(System.in);
    java.util.Scanner sc2 = new java.util.Scanner(System.in);

    //導入包後的方式
    import java.util.Random;
    import java.util.Scanner;
    //創建對象
    Random r1 = new Random();
    Random r2 = new Random();
    Scanner sc1 = new Scanner(System.in);
    Scanner sc2 = new Scanner(System.in);
    import導包代碼書寫的位置：在聲明包package後，定義所有類class前，使用導包import包名.包名.類名;

?

權限修飾符

 * A 權限修飾符有哪些
    在Java中提供了四種訪問權限，使用不同的訪問權限時，被修飾的內容會有不同的訪問權限，     
* B: 小結
    歸納一下：在日常開發過程中，編寫的類、方法、成員變量的訪問
    要想僅能在本類中訪問使用private修飾；
    要想本包中的類都可以訪問不加修飾符即可；
    要想本包中的類與其他包中的子類可以訪問使用protected修飾
    要想所有包中的所有類都可以訪問使用public修飾。
    註意：如果類用public修飾，則類名必須與文件名相同。一個文件中只能有一個public修飾的類。

代碼塊

 * A: 概述:
    程序中用大括號括起來的代碼叫代碼塊
 * B: 分類
  局部代碼塊  構造代碼塊  靜態代碼塊  同步代碼塊
 
 * C 局部代碼塊:
    局部代碼塊是定義在方法或語句中
    特點：
        以”{}”劃定的代碼區域，此時只需要關註作用域的不同即可
        方法和類都是以代碼塊的方式劃定邊界的

      class Demo{
            public static void main(String[] args)  {
                {
                         int x = 1;
                         System.out.println("普通代碼塊" + x);
                }
                int x = 99;
                System.out.println("代碼塊之外" + x);
            }
      }
      結果：
        普通代碼塊1
        代碼塊之外99
      局部代碼塊作用:可以限定變量的聲明周期.

* D: 構造代碼塊
    構造代碼塊是定義在類中成員位置的代碼塊
    特點：
        優先於構造方法執行，構造代碼塊用於執行所有對象均需要的初始化動作
        每創建一個對象均會執行一次構造代碼塊。
    public class Person {
        private String name;
        private int age;
        
         //構造代碼塊
        {
            System.out.println("構造代碼塊執行了");
        }
        Person(){
            System.out.println("Person無參數的構造函數執行");
        }
        Person(int age){
            this.age = age;
            System.out.println("Person（age）參數的構造函數執行");
        }
    }
    class PersonDemo{
        public static void main(String[] args)  {
            Person p = new Person();
            Person p1 = new Person(23);
        }
    }

* E: 靜態代碼塊
    靜態代碼塊是定義在成員位置，使用static修飾的代碼塊。
    特點：
        它優先於主方法執行、優先於構造代碼塊執行，當以任意形式第一次使用到該類時執行。
        該類不管創建多少對象，靜態代碼塊只執行一次。
        可用於給靜態變量賦值，用來給類進行初始化。
        public class Person {
            private String name;
            private int age;
             //靜態代碼塊
            static{
                System.out.println("靜態代碼塊執行了");
            }
        }
        
* F: 同步代碼塊(多線程學習)

總結

final：關鍵字，最終的意思

? final修飾的類：最終的類，不能被繼承

? final修飾的變量： 相當於是一個常量, 在編譯生產.class文件後，該變量變為常量值

? final修飾的方法： 最終的方法，子類不能重寫，可以繼承過來使用

static : 關鍵字， 靜態的意思

? 可以用來修飾類中的成員(成員變量，成員方法)

? 註意： 也可以用來修飾成員內部類

? 特點：

? 被靜態所修飾的成員，會被所有的對象所共享

? 被靜態所修飾的成員，可以通過類名直接調用，方便

? Person.country = "中國";

? Person.method();

? 註意事項：

? 靜態的成員，隨著類的加載而加載，優先於對象存在

? 在靜態方法中，沒有this關鍵字

? 靜態方法中，只能調用靜態的成員(靜態成員變量，靜態成員方法

匿名對象：一個沒有名字的對象

? 特點：

? 創建匿名對象直接使用，沒有變量名

? 匿名對象在沒有指定其引用變量時，只能使用一次

? 匿名對象可以作為方法接收的參數、方法返回值使用

內部類：在一個類中，定義了一個新類，這個新的類就是內部類

? class A {//外部類

? class B{// 內部類

? }

? }

? 特點：

? 內部類可以直接訪問外部類的成員，包含私有的成員

包:

? 包的聲明與訪問

? 類中包的聲明格式：

? package 包名.包名.包名…;

? 帶有包的類，創建對象格式：包名.類名 變量名 = new包名.類名();

? cn.yoci.Demo d = new cn.yoci.Demo();

? 導包的格式：

? import 包名.類名;

權限修飾符：

代碼塊：

? 局部代碼塊：定義在方法中的，用來限制變量的作用範圍

? 構造代碼塊：定義在類中方法外，用來給對象中的成員初始化賦值（優於構造方法）

靜態代碼塊：定義在類中方法外，用來給類的靜態成員初始化賦值

5、static、final、匿名對象、內部類、包、修飾符、代碼塊