命名要求

方法

分为普通方法、构造方法、set/get方法
方法名前加两种类型，有返回值（8大数据类型），无返回值（void）

普通方法

在对象实例化时可以调用多次

public static void fun(){     //static为静态方法，可以不加
}

方法名称和类名称一致

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.属性名 = 属性名}，特别注意的是数组也属于java类，在get方法中格式为public 类名称 get属性名(类属性名){return 属性名}，需要注意的是在数组生命中格式为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 | 区别 | this |super|
| :--------: | :----: | :----: | :--------: | :----: | :----: |:
|1 | 区别 | 调用本类构造、本类方法、本类属性 |子类调用父类构造、方法、属性|
| 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();
    }
}

方法重载

方法的名称相同，参数的类型和个数不同。

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、观察这个实例化的类里面调用的方法是否是已经被覆写过的，如果没覆写过则调用父类的。

//返回值一样，方法名相同，声明类型相同，数据类型相同，才为覆写
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]);
        }
}
}

Java 方法、关键字、重载、覆写