java抽象类和static

抽象类

并不是所有的类都是用来描绘对象的,

如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类.

• 抽象类 使用abstract 修饰类
• 抽象类不能被实例化。
• 在抽象类当中，可以有抽象方法，或者 非抽象方法!
• 什么是抽象方法，一个方法被abstract修饰，没有具体的实现。
• 只要包含抽象方法，这个类必须是抽象类
• 普通类 继承了这个抽象类，必须从写抽象类当中 的 抽象方法!
• 抽象类就是为了继承和重写的,所以抽象方法不能写成private final 等关键字修饰.
• 虽然不能实例化对象,但是简单定义变量仍然可以实现多态.
• 当一个子类没有重写抽象的父类方法时,可以把当前子类变成abstract修饰.但是后续继承此时子类的孙子类仍然需要重写刚才的函数.
• 抽象类当中不一定包含抽象方法.
• 可以有构造函数供子类完成初始化继承父类的成员.

abstract class Shape{//抽象类

    //1. 非抽象方法
//    public void draw(){//因为不能实例化对象,没有对象调用成员函数,没有实现函数的价值,但是可以实现
//        System.out.println("abstract Shape draw()");
//    }

    //2. 抽象方法,被abstract修饰,没有具体实现
    public abstract void draw();//不实现函数又会报错,所以加上abstract关键字即可
    //只要包含抽象方法,一定得是抽象类
}

abstract class Animal{
    public abstract void eat();

    public void func(){
        System.out.println("Animal func");
    }
    public String name;
}
class Dog extends Animal{
    public void eat(){
        System.out.println("Dog eat()");
    }
}
class Cat extends Animal{
    public void eat(){
        System.out.println("Cat eat()");
    }
}
abstract class Bird extends Animal{
    //为了不重写eat()方法,改为抽象类
}
class A extends Bird{
    public void eat(){
        
    }
}
public class AbstractClass {
    public static void test(Animal animal){//仍然实现多态
        animal.eat();
    }
    public static void main(String[] args) {
//        Shape shape =new Shape();//error 抽象类是不能实例化对象的
        Dog dog=new Dog();
        Cat cat=new Cat();
        test(dog);
        test(cat);
        //Dog eat()
        //Cat eat()
    }
}

static

class Student{
    public String name;
    public int age;//非静态成员变量,存放与创建的对象中(堆中)
    public static int class_id =102;//静态成员变量,类变量,存放在方法区中
    public Student(String n,int a,int sz){
        name=n;
        age=a;
        class_id =sz;//构造函数中也可以初始化静态成员变量,但是不建议,每个对象都会对这个公共值覆盖!!
    }
    public Student(String n,int a){
        name=n;
        age=a;
    }
    {
        //编译器会把非静态代码块放到构造函数代码之前
        //调用构造函数之前,先调用它
        System.out.println("非静态代码块/实例代码块/构造代码块->初始化非静态数据成员 ");
        name ="666";
        age=10;
        name1="777";//1
    }
    //同样是非静态成员,要看定义的顺序,谁在后面,谁就奏效
    public String name1="hahah";//1

    public Student(){
        System.out.println("不带参数的构造函数");
    }
    void func3(){
        System.out.println(this +" void func!");
    }
    public static void func(){//静态成员方法,类方法
        System.out.println("static func!");

        func2();//静态成员函数之间可以直接相互调用
//        func3();,非静态成员函数调用,需要传进来到底是哪个对象的引用,成员函数属于哪个对象
    }
    public static void func2(){
        System.out.println("static func2!");
    }
    public static void func4(Student s){//传过来哪个对象的引用,实现回调
        System.out.println("static func2!");
        s.func3();
    }
    public static void func5(){
        class_id =100;//静态成员函数只能修改和访问静态变量
//        name="666";//不能修改和访问成员变量
    }

    static{
        System.out.println("静态代码块->初始化静态数据成员/提前准备一些数据");
        //只要这个类被加载,静态代码块都会被执行的
        //但是只会被执行一次.
    }
    //设置和获取静态成员变量,最好就用静态函数.
    private static int hour=24;//就地初始化
    private String Date;//默认初始化为null
    public static int getHour(){
        return hour;
    }
    public static void setHour(int x){//使用函数初始化
        hour=x;
    }
}
public class staticDemo1 {
    public static void main(String[] args) {
        Student s=new Student();
        System.out.println(s.name+" "+s.age);
        //非静态代码块/实例代码块/构造代码块->初始化非静态数据成员
        //不带参数的构造函数
        //666 10
    }
    public static void main1(String[] args) {
        Student s1=new Student("yuanwei",22);
        System.out.println(s1.name);
        System.out.println(s1.name);
        System.out.println(s1.class_id);
        System.out.println(Student.class_id);//正确的是通过类名访问
        Student s2=null;
        System.out.println(s2.class_id);//因为class_id不属于对象,属于类,所以可以通过null访问
        s1.func();
        s2.func();
        Student s3=new Student("xiaoawei",22);
        Student.func4(s3);
        System.out.println(Student.getHour());
    }
}

• 静态代码不管生成多少个对象,都只会被加载一次
• 静态成员变量属于整个类的属性,因此是在JVM加载类时开辟空间并初始化的
• 如果一个类中包含多个静态代码块,在编译代码时,会根据出现的先后顺序依次执行合并
• 实例代码块/非静态代码块只有在创建对象时才会被执行
• 执行的先后顺序: 静态代码块->非静态代码块->不带参数的构造函数

整理

1. java中,在类的方法中,不能声明和定义静态变量(类变量).经验证,C++中是可以的

class Test{
    static int i=0;
    public int Method(){
        //static int i=0;//error 编译报错
        i++;
        return i;
    }

    public static void main(String[] args) {
        Test testi=new Test();
        testi.Method();
        Test testj=new Test();
        int j= testj.Method();
        System.out.println(j);//2
    }
}

2. 静态代码块执行顺序

class Test88{
    static int b=6;
    static{
        b+=9;
    }

    public static void main(String[] args) {
        System.out.println(b);//25
    }
    static {
        b+=10;
    }
}