【我的Java筆記】第五課


匿名對象

1.定義:沒有名字的對象
2.作用:節省代碼。在很多情況下針對某個方法只需調用一次的情況下
      匿名對象可以調用方法,也可以給成員變量賦值,同時也可作為方法的參數進行傳遞

封裝

1.概念:隱藏對象的屬性和細節,僅對外提供公共的方法進行訪問
2.關鍵字:“private”
    a.當類的成員變量使用private 修飾符修飾,那么就不可以直接訪問到該成員變量
    b. 當使用private 修飾的成員變量或者成員方法,僅能在本類中使用
    c. private 對於main 方法的修飾也可以產生作用的
3.JavaBean類:
    所有成員變量都使用private 進行修飾,並且對外提供可訪問的設置值和獲取值的set,get方法
    不同的應用場景可能命名不同,在數據庫的應用中稱為“ POJO
4.main方法細節:
    a.每個類中都可以存在main方法,但是當執行的時候會優先查看public 的class 中是否有main 方法
    b.如果沒有public 的class, 那么會按照文件名優先查找類中的main方法
    c.必須定義為public

例1 private:
       public class DemoPrivate{
public static void main(String[] args){
Person person =new Person();
person.name = "diffo";
person.setAge(20);
person.eat();
person.action();
}

}


class Person{
String name;
private int age;

//獲取age
void setAge(int ageParm){
if(ageParm>0 && ageParm<150){
age = ageParm;
}
}

void eat(){
  System.out.println("eat");
}

void action(){
eat();
speak();
}

void speak(){
System.out.println("speak!: "+name+" . "+age);
}
}

例2 JavaBean:


優先原則

對於一個類的成員方法來說,如果傳遞的形參的變量名稱和類的成員變量名稱相同,Jvm在處理的時候優先當做方法的形參來處理

“this”關鍵字

1.含義:代表了對當前對象的引用(當前調用誰,方法中的this即代表誰)
   注:1.對於一個類的成員方法來說,如果傳遞的形參的變量名稱和類的成員變量名稱相同,Jvm在處理的時候優先當做方法的形參來處理
           2. 可以加在成員變量的前面來指定對應的引用,也可以加在成員方法的前面

初始化類成員變量的方式

1.在定義成員變量的同時進行賦值
2.提供外界可訪問到的方法,在方法中進行賦值
3.通過構造方法進行賦值
   例:


關鍵字“static”

1.隨着類加載而加載
   靜態方法區中來保存靜態成員變量

2.優先於對象創建
   Person.className = "java";

3.被類的所有對象共享
   靜態的成員變量會保存在該class的靜態方法區中,所以每個對象看到的都是同一份.

4.可以通過類名來訪問也可以通過對象名來訪問(效果相同)

5.推薦通過類名來訪問
   靜態的成員,一般稱為類相關的成員

6.static 修飾符既可以修飾成員變量,也可以修飾成員方法。 且修飾之后,就可以通過類名來直接訪問到
    類名.方法名 ( );

7.this 變量在靜態方法中不可以使用

8.靜態方法中只能訪問靜態成員變量和靜態方法
  非靜態方法既可以訪問靜態成員和方法也可以訪問非靜態成員和方法(不建議非靜態方法去訪問靜態成員和方法)

例:



main方法

修飾符  返回類型  方法名 (參數列表){

                     ·······
}


public static void main(String[ ] args){


}

1.public: 最大的一個訪問權限,使得Jvm能夠成功調用
2.static: 類相關的,與對象無關.。通過A.main([ ]);
              例:public class A{
                              main(){
                            System.("   ");
                              }
                       }

3.void: 不需要返回值.
4.方法名: main 
5.參數列表: 執行的時候,可以傳遞參數

工具類

1.全部都是靜態的方法
2.所以可以通過:  類名.functionName( ) 方式來訪問
注:(1)一般都會對默認構造方法進行私有化處理,來防止別人使用時習慣性的創建對象來調用方法
         (2)將其中的方法定義為“static”

例:長方形工具類(求邊長和面積)

public class User{	public static void main(String[] args){
Rectangle rectangle=new Rectangle();
//賦值
rectangle.setLength(4);
rectangle.setWidth(5);
//調長方形求面積、周長工具
RectangleUtil.getAre(rectangle);
RectangleUtil.getCircumLength(rectangle);
}
}

//長方形類(JavaBean類)
class Rectangle{
private int length;
private int width;

void setLength(int length){
this.length=length;
}
int getLength(){
return this.length;
}

void setWidth(int width){
this.width=width;
}
int getWidth(){
return this.width;
}
}

//長方形工具
class RectangleUtil{
//私有化此類
private RectangleUtil(){

}

static void getAre(Rectangle rectangle){
System.out.println("長方形的面積="+rectangle.getLength()*rectangle.getWidth());
}
static void getCircumLength(Rectangle rectangle){
System.out.println("長方形的周長="+(rectangle.getLength()+rectangle.getWidth())*2);
}
}


代碼塊

概念:使用{ } 括起來的代碼,稱為代碼塊
分類:根據位置和聲明的不同,可將代碼塊分為:局部代碼塊、構造代碼塊、靜態代碼塊和同步代碼塊(多線程)

一、 局部代碼塊
  (1)限定了變量的生命周期,變量在局部代碼塊中定義。出了局部代碼塊之后,就訪問不到了。
            在局部代碼塊中定義的變量,在出了代碼塊之后,內存就會釋放掉。
  (2)作用: 主要就是節約內存.
  (3)局部代碼塊中定義的變量,雖然說作用域是局部的,但是如果存在外部嵌套的代碼塊,且在局部代碼塊定義之前就定義了某               個變量,那么在我們局部的代碼塊中就不可以定義相同名稱的變量
  注:但是如果在局部代碼塊執行之后,去定義一個和局部代碼塊中相同名稱的變量,是可以的。因為局部代碼塊中的變量已經失去           了作用域范圍。
  
  例:
  


二、構造代碼塊
  (1)概念:在類中的方法外出現,每次調用構造方法的時候,都會優先先調用構造代碼塊
  (2)特點:每創建一個對象,都會調用一次構造代碼塊
  (3)作用:如果存在很多重載的構造方法,而且每個里面需要執行相同的邏輯,那么就可以考慮將這些代碼提取到構造代碼塊中                           來執行。可以讓我們的代碼結構更簡練。增強了維護性

三、靜態代碼塊
  (1)概念:類中方法外出現,並用“static” 關鍵字來進行修飾
  (2)特點:隨着類加載的時候執行
  (3)用處:適用於整個軟件的生命周期中,只需要執行一次的業務邏輯代碼(數據庫)

    例:
          


繼承

1.特點:
  (1) 子類繼承父類的成員變量和成員方法。但是他們各自擁有的各自的成員變量,故父類的值子類並不會繼承。
  (2)對於父類中的私有成員變量和私有方法,子類無法繼承
2.繼承的優點:提高了代碼的復用性和維護性
   繼承的缺點:類的耦合性增強了(開發的原則:高內聚、低耦合)
      a.耦合: 類和類之間的關系
      b.內聚: 自己獨立完成某件事情的能力
3.只支持單繼承,但可以多層繼承
   繼承是相互疊加的。子類繼承的時候,會遞歸似的尋找父類中是否還存在繼承,會繼承整個層級直到最根部類的屬性和方法
4.構造方法無法繼承(但可調用父類中的構造方法)
5.繼承關系中訪問成員變量
 (1)不同名的成員變量
           子類可以直接訪問和使用父類繼承的非私有的成員變量
 (2)同名的成員變量
           優先原則: 如果子類中定義了和父類中相同名字的成員變量,會
優先訪問子類 的該變量
           如果想要依然訪問到父類中的同名變量,我們需要加上“super”關鍵字來獲取
 (3)this和super的比較
           this::對當前對象的引用
super父類對象的引用

this:可以訪問到子類中的變量,也可以訪問到父類中的變量
super:訪問父類中的變量
          

6.繼承關系中訪問成員方法

  (1)不同名的方法

           子類可直接調用到父類的方法

  (2)同名的方法

          同名方法::指的返回值類型(父子類關系是可以的),方法名稱以及方法接收的形參列表要一模一樣

         注:當子類在調用該同名方法時,會優先調用子類的該方法

7.方法重寫

   存在於繼承關系中,子類中定義的方法和父類中的方法完全一樣的時候(返回值類型父子類關系是可以的),我們在通過子類對象來訪問該方法的時候,    就會調用到子類的方法。


  注: 方法重寫注意事項:

(1)子類不能重寫父類的私有方法
(2)子類重寫父類方法的時候,提供的訪問權限不能更低.
(3)子類覆蓋父類方法,如果父類是靜態方法的話,子類也必須是靜態方法才可以成功覆蓋,也就是重寫

8.方法重載
  (1)同一個類中,如果有多個相同方法名的方法,但是他們的形參列表是不同的,那么這種方式我們就稱為方法的重載
   在調用時Jvm可以通過不同的形參來區別不同的方法

           注:關於方法重寫和方法重載的返回值約束:
方法重載::僅返回值不同是不能重載的。必須參數列表不同。
方法重寫::返回值類型(父子類關系是可以的) 要求返回值類型也要相同的.

9.繼承中構造方法的調用
  (1)特點:
         a.創建子類對象的時候,一定會優先去創建父類的對象。 因為要創建父類對象,所以就需要去調用到父類的構造方法.
 b.對於所有的類的構造方法的第一行,第一行在我們沒有自己添加this(...)或者super(...)的情況下都會去幫我們默認的添加super()
         c.如果父類中不存在默認的構造,子類依然要創建對象,那么子類就需要顯示的指明調用的是哪一個父類對象,才能保證父類對象創建的成功

  注:a.一定要保證父類對象的創建成功
  b.構造方法的第一行,如果我們添加了自己調用的this(...),或者super(...), 系統就不會為我們默認的添加super().
  c.this(...)或者super(...) 必須放到第一行。二者只能有其一

例1:
/*
在創建子類對象的時候,會先調用到父類的構造方法,去創建父類的對象。
*/

public class ExtendsDemo5{

public static void main(String[] args){
Son son = new Son();
System.out.println("-------------");
}

}

class Father{

Father(){
System.out.println("father 默認構造");
}


Father(int num){
System.out.println("father 有參構造");
}
}

class Son extends Father{

Son(){
//super(10);
this(10); //this(10), 所以就不會幫我們再去默認添加super(),
System.out.println("son 默認構造");
}

Son(int num){
super(10);
//super(10); //第一行沒有this或者super,就會幫我們添加super()
System.out.println("son 有參構造");
}


}





例2:

/*
定義長方形類和正方形類, 長方形繼承正方形並且重寫計算面積和周長的方法.
*/

public class ExtendsDemo{
public static void main(String[] args){
Square square=new Square(3);
System.out.println("正方形的面積="+square.getAre());
System.out.println("正方形的周長="+square.getCircumLength());

Rectangle rectangle=new Rectangle(4,5);
System.out.println("長方形的面積="+rectangle.getAre());
System.out.println("長方形的周長="+rectangle.getCircumLength());
}
}

class Square{
private int length;

Square(int length){
this.length=length;
}
/* 默認構造器
Square(){

}
*/

int getAre(){
return this.length*this.length;
}
int getCircumLength(){
return this.length*4;
}
}

class Rectangle extends Square{
private int length;
private int width;

Rectangle(int length,int width){
super(1); //添加父類默認構造器
this.length=length;
this.width=width;
}

int getAre(){
return this.length*this.width;
}
int getCircumLength(){
return (this.length+this.width)*2;
}
}




final關鍵字

1.final修飾類
   若final修飾一個類,該類不能被繼承.
2.final修飾類的成員變量
   該成員變量的值不可修改
  注: 在對象創建之前都可以對該變量進行初始化(三種方法同時只可用一種):
a.構造代碼塊中可以進行初始化
b.構造方法中可以進行初始化
c.定義成員變量的時候,可以直接進行初始化.

3.在大多數的情況下,final成員變量都會配合public static 一起使用.
例:
//常量類, 變量命名都要大寫,而且單詞之間要用_分割開.
class A{
   public static final double PI = 3.14;
   public static final double RATE = 2.86;
}

A.PI
A.RATE

4.靜態成員變量的初始化時機:
 (1)在創建靜態final成員變量的時候,直接進行初始化
 (2)在靜態代碼塊中進行初始化.
           例:static{
   ·····
   }







隨堂練習:


/*
* 定義一個容量為10的數組,其中元素為0到27間的隨機數
* */

import java.util.Arrays;
import java.util.Random;

public class Demo {
public static void main(String []args){

//方法1:運用Random類做隨機數
/*
Random r=new Random();
int [] arr=new int [10] ;
for(int i=0;i<arr.length;i++){
int k=r.nextInt(28);
arr[i]=k;
}
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
*/


//方法2:運用Math下的random方法做隨機數
int [] arr=new int [10] ;
for(int i=0;i<arr.length;i++){
boolean flag=true;
while(flag){
int k=(int)(Math.random()*100);
if(k<=27){
arr[i]=k;
flag=false;
}else{
flag=true;
}
}
}
Arrays.sort(arr); //數組的排序方法
System.out.println(Arrays.toString(arr)); //將輸出的數組轉換為字符串輸出
}

}
















2017.10.14 /10.15















注意!

本站转载的文章为个人学习借鉴使用,本站对版权不负任何法律责任。如果侵犯了您的隐私权益,请联系我们删除。



 
  © 2014-2022 ITdaan.com 联系我们: