命名要求

命名要求

方法

分為普通方法、構造方法、set/get方法
方法名前加兩種類型，有返回值（8大數(shù)據(jù)類型），無返回值（void）

普通方法

在對象實例化時可以調用多次

public static void fun(){     //static為靜態(tài)方法，可以不加
}

方法名稱和類名稱一致

set/get方法

class A1{
    private String name;
    public void setName(String name){
        this.name = name;
    }
    public String（返回類型） getName(){
        return this.name;
    }
}

set方法兩種作用，修改內容和設置內容。set方法無返回值，用法public void set屬性名(類 屬性名){this.屬性名 = 屬性名}，特別注意的是數(shù)組也屬于java類，在get方法中格式為public 類名稱 get屬性名(類 屬性名){return 屬性名}，需要注意的是在數(shù)組生命中格式為public 類名稱[ ] get屬性名(類 屬性名){return 屬性名}。注意[ ]

構造方法

在使用關鍵字new，實例化新對象時調用，而且此方法只可以調用一次。

class Book{
        public Book(){  //構造方法的方法名必須與類名一樣
    }
}

static關鍵字

一、定義屬性（用static定義屬性，表示公有共享信息，若有一個修改了屬性內容，則其他全部改變）

class Book{
    private String name ;
    private double price;
    static String pub = "beida";
    
    public Book(String name,double price){
        this.name = name;
        this.price = price;
        
    }
    
    public  String getInfo(){
        return "Name:"+this.name+" "+"Price:"+this.price+"Pub:"+this.pub;
    }   
}
public class Exten{
    public static void main(String []args){
        Book ba = new Book("Java",36.1);
        Book bb = new Book("Android",12.4);
        ba.pub = "qinghua";
        System.out.println(ba.getInfo());
        System.out.println(bb.getInfo());
    }
}
-------------------------------------------------
用static定義前后結果
F:\prac>java Exten
Name:Java Price:36.1Pub:qinghua
Name:Android Price:12.4Pub:beida

F:\prac>javac Exten.java

F:\prac>java Exten
Name:Java Price:36.1Pub:qinghua
Name:Android Price:12.4Pub:qinghua

static定義方法

this/super關鍵字

this/super 可調用方法、屬性

| NO | 區(qū)別 | this |super|
| :--------: | :----: | :----: | :--------: | :----: | :----: |:
|1 | 區(qū)別 | 調用本類構造、本類方法、本類屬性 |子類調用父類構造、方法、屬性|
| 2 | 形式 | 先查找本類，若無查找父類 |不查找子類，直接調用父類|
|3 | 特殊 |表示本類當前對象 |~||

final

1、final定義的類不能有子類；

final class A{
}
class B extends A{ //錯誤
}

2、使用final定義的方法不能被子類所覆寫；

final class A{
     public final void  fun(){   //注意final和void順序，不可錯
   }
}
class B extends A{ //錯誤
    public  void  fun(){
   }
}

3、使用final定義的變量就變成了常量，常量在定義的時候必須設置好內容，并不能被修改。
4、全局常量
常量全部大寫STEDENTNAME，變量studentName，方法public void setName

public static final String MSG = "ff";

this.方法()/super.方法()

this.方法()會首先查找本類中的方法，若查找到直接調用，若查詢不到則查詢父類，有則調用，沒有則編譯報錯（找不到此方法）。
super.()方法會直接查詢父類，不會查詢子類

class A{
    public void fun(){
        print();
    }
    public void print(){
        System.out.println("A");
    }
}
class B extends A{
    public void print(){
        super.print();    //this.print();
        System.out.println("B");
    }
}
public class Exten {
    public static void main(String [] args){
        B b = new B();
        b.fun();
    }
}

方法重載

方法的名稱相同，參數(shù)的類型和個數(shù)不同。

public class Exten {
    public static void main(String args []){
        System.out.println(fun(3,5));
        System.out.println(fun(3,5,9));
        System.out.println(fun(3.1,5.6));
    }
    public static int fun(int x,int y){
        return x+y;
    }
    public static int fun(int x,int y,int z){
        return x+y+z;
    }
    public static double fun(double x,double y){    
    ----public static double fun(int x,int y)---錯誤，需一致
        return x+y;
    }
}

方法覆寫（父類功能不足，而子類還必須使用，就會使用覆寫）

1、觀察實例化的是那一個類；
2、觀察這個實例化的類里面調用的方法是否是已經(jīng)被覆寫過的，如果沒覆寫過則調用父類的。

//返回值一樣，方法名相同，聲明類型相同，數(shù)據(jù)類型相同，才為覆寫
class A{
    public void fun(){
        System.out.println("A類中的方法");
    }
}
class B extends A{
    public void fun(){
        System.out.println("B類中的方法");
    }
}
class C extends A{
//Exten.java:12: 錯誤: C中的fun()無法覆蓋A中的fun()；
//若改為public String  fun()  ^ 返回類型String與void不兼容
    public void fun(){   
        System.out.println("C類中的方法");
    }
}
public class Exten {
    public static void main(String [] args){
        B b = new B();
        b.fun();
        C c = new C();
        c.fun();
    }
}

3、權限問題（public>默認>private）
子類不可以使用比父類更高的權限，使用后就不是覆寫了

//覆寫
class A{
    public void fun(){
        print();
    }
    public void print(){
        System.out.println("A");
    }
}
class B extends A{
    public void print(){
        System.out.println("B");
    }
}
public class Exten {
    public static void main(String [] args){
        B b = new B();
        b.fun();
    }
}
------------------------------------------------------
//非覆寫
class A{
    public void fun(){
        print();
    }
    private void print(){
        System.out.println("A");
    }
}
class B extends A{
    public void print(){
        System.out.println("B");
    }
}
public class Exten {
    public static void main(String [] args){
        B b = new B();
        b.fun();
    }
}

屬性覆寫

基礎父類

class Array{
    private int [] data;
    //private int len;
    private int foot;
    public Array(int len){
        if(len>0){
            this.data = new int [len];
        }else{
            this.data = new int [1];
        }
    }
    public boolean add(int num){
        if(this.foot<this.data.length){
            this.data[this.foot++] = num;
            return true;
        }
        return false;
    }
    public int [] getData(){
            return this.data;
        }
    }
}
public class Demo{
    public static void main(String args[]){
        Array a = new Array(3);
        System.out.println(a.add(10));
        System.out.println(a.add(20));
        System.out.println(a.add(30));
        System.out.println(a.add(100));
        System.out.println(a.add(100));
        int [] temp = a.getData();
        for(int x=0;x<temp.length;x++){
            System.out.println(temp[x]);
        }
}
}