Java类

Java的类

一个类可以包括：变量（）；方法；构造方法；

public class Shape {
    public String name = "clicle";
    public int age = 12;
    public int length = 0;

    public Shape(String name, int age, int length) {
        this.name = name;
        this.age = age;
        this.length = length;
    }

    public void draw() {
        System.out.println("res:" + this.name + "-" + this.age + "-" + this.length + "\n" + "Shape class draw()");
    }
}

局部变量

在方法内部声明的变量为局部变量，该变量只能在该方法内使用，运行结束就被销毁

public class LocalVariable {
    public static void main(String[] args) {
        int a = 10;
        int b = 10;
        int c = a + b;
        System.out.println(c);
    }
}

成员变量

在类内部，但是在方法体外声明的为成员变量或者实例变量。

public class InstanceVariable {
    int data = 88;
    public static void main(String[] args) {
        InstanceVariable iv = new InstanceVariable();
        System.out.println(iv.data); // 88
    }
}

静态变量

使用static关键字修饰的变量（类变量）。

public class StaticVariable {
    static int data = 99;
    public static void main(String[] args) {
        System.out.println(StaticVariable.data); // 99
    }
}

常量

使用final定义的成员变量。

public class FinalVariable {
    final String CHEN = "沉";
    static final String MO = "默";
    public static void main(String[] args) {
        FinalVariable fv = new FinalVariable();
        System.out.println(fv.CHEN);
        System.out.println(MO);

    }
}

java的方法

静态方法。

静态方法与类方法，静态方法虽然是属于类的，但是不属于类的实例的，也就是类可以直接调用，但是实例也可以调，只是不推荐。

//	访问权限 static 返回类型 方法名 (参数列表)//
	public static String charLink(String s1, String s2) {
        String result = s1 + s2;
        return result;
    }

实例方法

//  另外一种方法
     Test objCharLinkTwo = new Test();
     String result = objCharLinkTwo.charLinkTwo(s1, s2);
     System.out.println(result);

	public String charLinkTwo(String s1, String s2) {
        String result = s1 + s2;
        return result;
    }

抽象方法

:没有方法体的方法就是抽象方法。它总是写在抽象类中进行声明。
抽象方法在类中不进行实现，但是在子类中必须要进行重写。

//在抽象类FatherClass进行定义个抽象类
abstract class FatherClass {
    abstract void abstractDemo();
}
//在子类中override
public class SonClass extends FatherClass{
    @Override
    void abstractDemo() {
        System.out.println("this is son abstractDemo");
    }

    public static void main(String[] args) {
        SonClass chenzi=new SonClass();
        chenzi.abstractDemo();
    }
}

构造方法

默认构造方法

public class Bike {
    Bike() {
        System.out.println("一辆自行车被创建");
    }

    public static void main(String[] args) {
        Bike bike = new Bike();
    }
}

参数构造方法

public class Bike {
    String bikeBride="yongjiu";
    int bikeLength=100;
    public Bike(String bride,int length) {
        this.bikeBride=bride;
        this.bikeLength=length;
        System.out.println("一辆自行车被创建");
    }

    public static void main(String[] args) {
        Bike bike = new Bike("xxx",120);
    }
}

抽象类

抽象类的定义就是如下，抽象类里可以有静态方法（静态方法感觉更像是一种特别的变量。。。）

abstract class AbstractPlayer {
    public String abstractVar = "";
    public int abstractIntVar = 0;
    public static void abstractPlayerTest() {
        System.out.println("this is 抽象类的静态方法");
    }
//
    abstract void dayLogPrinter();
    public static void main(String[] args) {
// 			NOTE
//        AbstractPlayer basketBall=new ();
    }
}