13_Java面向對象_第13天（static、final、匿名對象、內部類、包、修飾符、代碼塊）_講義
今日內容介紹
一、final 關鍵字
二、static 關鍵字
三、匿名對象
四、內部類
五、包的聲明與訪問
六、訪問修飾符
七、代碼塊java
01final關鍵字概念
- A: 概述
繼承的出現提升了代碼的複用性，並方便開發。但隨之也有問題，有些類在描述完以後，不想被繼承， 或者有些類中的部分方法功能是固定的，不想讓子類重寫。但是當子類繼承了這些特殊類以後， 就能夠對其中的方法進行重寫，那怎麼解決呢？ 要解決上述的這些問題，須要使用到一個關鍵字final，final的意思爲最終，不可變。 final是個修飾符，它能夠用來修飾類，類的成員，以及局部變量。
02final修飾類義
- A: final 修飾類
final修飾類不能夠被繼承，可是能夠繼承其餘類。
- B: 案例
class Yy {} final class Fu extends Yy{} //能夠繼承Yy類 class Zi extends Fu{} //不能繼承Fu類
03final修飾方法
- 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(){} }
04final修飾局部變量
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屬性值可更改。
05final修飾成員變量
- A: 修飾成員變量
修飾成員變量，須要在建立對象前賦值，不然報錯。(當沒有顯式賦值時，多個構造方法的均須要爲其賦值。)
- B: 案例
class Demo { //直接賦值 final int m = 100; //final修飾的成員變量，須要在建立對象前賦值，不然報錯。 final int n; public Demo(){ //能夠在建立對象時所調用的構造方法中，爲變量n賦值 n = 2016; } }
06static的概念
A：概念多線程
當在定義類的時候，類中都會有相應的屬性和方法。而屬性和方法都是經過建立本類對象調用的。 當在調用對象的某個方法時，這個方法沒有訪問到對象的特有數據時，方法建立這個對象有些多餘。 但是不建立對象，方法又調用不了，這時就會想，那麼咱們能不能不建立對象，就能夠調用方法呢？ 能夠的，咱們能夠經過static關鍵字來實現。static它是靜態修飾符，通常用來修飾類中的成員。
07static修飾的對象特有數據
- 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 } }
08static的內存圖
09static注意事項_靜態不能直接調用非靜態
- 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(); } }
10static靜態的使用場景
A: 使用場景dom
static能夠修飾成員變量和成員方法。 何時使用static修飾成員變量？ 加static修飾成員的時候，這個成員會被類的全部對象所共享。通常咱們把共性數據定義爲靜態的變量 何時使用static修飾成員方法？ 靜態的方法只能訪問靜態的成員，若是靜態方法中引用到了靜態的其餘成員，那麼這個方法須要聲明爲靜態的方法。
11對象中的靜態調用
- A: 對象的靜態調用
在多態中，非靜態編譯看父類，運行看子類，父類沒有編譯失敗。 但多態中的靜態方法,編譯看父類,運行仍然看父類。由於靜態和對象沒有關係，屬於靜態綁定。- B: 舉例
public class Test{ public static void main(String[] args){ Fu f = new Zi(); f.show(); //父類的引用和父類的方法綁定,和對象無關,不會在運行時動態的執行子類特有的方法。 } }
12定義靜態常量
- A: 靜態常量
- 開發中，咱們想在類中定義一個靜態常量，一般使用public static final修飾的變量來完成定義。
此時變量名用所有大寫，多個單詞使用下劃線鏈接。
- 開發中，咱們想在類中定義一個靜態常量，一般使用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
13匿名對象
* 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());
}
}
14內部類
- A: 內部類的概述
將類寫在其餘類的內部，能夠寫在其餘類的成員位置和局部位置，這時寫在其餘類內部的類就稱爲內部類。 其餘類也稱爲外部類。
- B: 何時使用內部類
在描述事物時，若一個事物內部還包含其餘可能包含的事物，好比在描述汽車時，汽車中還包含這發動機， 這時發動機就可使用內部類來描述。 class 汽車 { //外部類 class 發動機 { //內部類 } }- C: 內部類的分類
內部類分爲成員內部類與局部內部類。 咱們定義內部類時，就是一個正常定義類的過程，一樣包含各類修飾符、繼承與實現關係等。 在內部類中能夠直接訪問外部類的全部成員。
15成員內部類的調用格式
* 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();
}
16成員內部類的同名變量調用
- A: 代碼實現
public class Outer { int i = 1; class Inner { int i = 2; public void inner(){ int i = 3; System.out.println(Outer.this.i); } } }
17局部內部類
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(); }
18匿名內部類
A: 概述測試
內部類是爲了應對更爲複雜的類間關係。查看源代碼中會涉及到，而在平常業務中很難遇到，這裏不作贅述。 最經常使用到的內部類就是匿名內部類，它是局部內部類的一種。 定義的匿名內部類有兩個含義： 臨時定義某一指定類型的子類 定義後即刻建立剛剛定義的這個子類的對象
B: 本質this
匿名內部類的本質是一個實現了接口或繼承了某個類的子類匿名對象.
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(); * * 匿名內部類,簡化問題: 定義實現類,重寫方法,創建實現類對象,合爲一步完成 */
測試類:code
public class Test {
public static void main(String[] args) {
//使用匿名內部類
/*
* 定義實現類,重寫方法,建立實現類對象,一步搞定
* 格式:
* new 接口或者父類(){
* 重寫抽象方法
* };
* 從 new開始,到分號結束
* 建立了接口的實現類的對象
*/
new Smoking(){
public void smoking(){
System.out.println("人在吸菸");
}
}.smoking();
}
}
19匿名內部類_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();
}
}
20包的概念
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 {}
22導入包
- 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包名.包名.類名;
23權限修飾符
- A 權限修飾符有哪些
在Java中提供了四種訪問權限，使用不一樣的訪問權限時，被修飾的內容會有不一樣的訪問權限， 如下表來講明不一樣權限的訪問能力： public protected default private 同一類中 √ √ √ √ 同一包中(子類與無關類) √ √ √ 不一樣包的子類 √ √ 不一樣包中的無關類 √- B: 小結
概括一下：在平常開發過程當中，編寫的類、方法、成員變量的訪問 要想僅能在本類中訪問使用private修飾； 要想本包中的類均可以訪問不加修飾符便可； 要想本包中的類與其餘包中的子類能夠訪問使用protected修飾 要想全部包中的全部類均可以訪問使用public修飾。 注意：若是類用public修飾，則類名必須與文件名相同。一個文件中只能有一個public修飾的類。
24代碼塊
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: 同步代碼塊(多線程學習)
做業測試
1.final修飾類，修飾方法，修飾變量有什麼特色?
二、package,import,class之間有沒有順序關係？
三、Java中的權限修飾符有哪些？
四、內部類的訪問特色是什麼？
五、局部內部類訪問局部變量，該局部變量必須用哪一個關鍵字修飾，爲何？
六、內部類的格式? 它的本質是什麼？
七、匿名內部類的前提條件，格式分別是什麼？
8.代碼塊的分類?
9.不運行下面代碼: 口述打印結果
class Student {
static {
System.out.println("Student 靜態代碼塊");
}
{
System.out.println("Student 構造代碼塊");
}
public Student() {
System.out.println("Student 構造方法");
}
}
class Demo2_Student {
static {
System.out.println("Demo2_Student靜態代碼塊");
}
public static void main(String[] args) {
System.out.println("我是main方法");
Student s1 = new Student();
Student s2 = new Student();
}
}
十、請編寫一個抽象類Phone,兩個抽象方法,call() sendMessage() 兩個子類OldPhone 和 NewPhone , 其中NewPhone想添加一個玩遊戲的功能. 請根據接口的思想實現,並用匿名內部類的方式調用玩遊戲的功能.
相關文章
- 1. static、final 、對象、修飾符
- 2. javaSE day13 final static 匿名對象 內部類 包的聲明與訪問 四種訪問修飾符 代碼塊
- 3. JavaSE基礎知識——Day13 面向對象：final、static、匿名對象、 內部類、包的聲明與訪問、四種訪問修飾符、代碼塊
- 4. 【面向對象】內部類，匿名類
- 5. 10.面向對象（匿名內部類）
- 6. JAVA基礎 面向對象（四） 代碼塊 static 抽象類 內部類
- 7. #### java 6 面向對象、匿名對象、權限修飾符、構造方法
- 8. Java 匿名對象 內部類 包的聲明與訪問 訪問修飾符
- 9. 面向對象（匿名對象）
- 10. 10_Java面向對象_第10天（繼承、抽象類）_講義
- 更多相關文章...
- • PHP 面向對象 - PHP教程
- • Lua 面向對象 - Lua 教程
- • IntelliJ IDEA代碼格式化設置
- • 使用阿里雲OSS+CDN部署前端頁面與加速靜態資源
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. static、final 、對象、修飾符
- 2. javaSE day13 final static 匿名對象 內部類 包的聲明與訪問 四種訪問修飾符 代碼塊
- 3. JavaSE基礎知識——Day13 面向對象：final、static、匿名對象、 內部類、包的聲明與訪問、四種訪問修飾符、代碼塊
- 4. 【面向對象】內部類，匿名類
- 5. 10.面向對象（匿名內部類）
- 6. JAVA基礎 面向對象（四） 代碼塊 static 抽象類 內部類
- 7. #### java 6 面向對象、匿名對象、權限修飾符、構造方法
- 8. Java 匿名對象 內部類 包的聲明與訪問 訪問修飾符
- 9. 面向對象（匿名對象）
- 10. 10_Java面向對象_第10天（繼承、抽象類）_講義