Java基础（十二）：statsic关键字、代码块、抽象类、接口详解

面向对象

1. static关键字详解

package com.oop.demo07;

public class Student {
    private static int age;         //静态变量
    private  double score;          //非静态变量
    public void run(){              //非静态方法
        System.out.println("run");
    }
    public static void go(){        //静态方法
        System.out.println("go");
    }

//---------------------------------------------------------------------------

    public static void main(String[] args) {
        System.out.println(Student.age);//不用new,和类一起加载出现的
        Student.go();
        //----------------------------------------------------------------
        Student student = new Student();//需要new实例才能运行
        System.out.println(student.age);
        System.out.println(student.score);
        student.run();
    }
}

结果

0
go
0
0.0
run

2. 代码块

package com.oop.demo07;

public class Person {
    {System.out.println("匿名代码块：赋初始值");}          //第二步运行
    static {System.out.println("静态代码块");}           //第一步运行,且只执行一次！
    public Person() {System.out.println("构造方法");}    //第三步运行

    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("========================");
        Person person2 = new Person();


    }
}

结果

静态代码块
匿名代码块
构造方法
========================
匿名代码块
构造方法

3. 被 【final】修饰 的类不可被继承

4. 静态导入包

package com.oop.demo07;

//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;


public class Test {
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
    }
}

结果

0.32698615013033994
3.141592653589793

5. 抽象类

• 抽象方法，只有方法名字，没有方法的实现！
• 抽象类的方法必须要由子类实现------快捷键【Ctrl+i】
• 抽象类：单继承~（接口可以多继承）
• 不能 new 这个抽象类，只能靠子类去约束它：约束~
• 类中存在抽象方法，那么就类必须是抽象类
• 抽象类中可以写普通方法

package com.oop.demo08;
//抽象类
public abstract class Action {
    public abstract void doSomething();     //抽象方法，只有方法名字，没有方法的实现！
}

package com.oop.demo08;
//抽象类的方法必须要由子类实现
public class A extends Action{
    public void doSomething() {
    }
}

• 作用：提供类模板但不实现，子类有需要在去继承，根据自己的需要来具体化！

6. 接口

• 普通类：只有具体方法
• 抽象类：具体实现和规范（抽象方法）都有
• 接口：只有规范！自己无法写方法~专业的约束！约束和实现分离：面向接口编程
• 接口的本质是契约
• 接口不能被实例化，接口中没有构造方法
• interface 接口的关键字，接口都需要有实现类
• 类可以实现多接口，通过 implements 接口，接口
• 实现类通过【Ctrl+i】可以将接口中的规范展开

接口 UserService

package com.oop.demo09;

//interface  接口的关键字，接口都需要有实现类
public interface UserService {
    //  接口中所有定义的属性都是常量
    public static final int AGE = 99;
    
    //接口中的所有定义的方法其实都是抽象    public abstract
    public abstract void add(String name);//增
    public abstract void delete(String name);//删
    public abstract void update(String name);//改
    public abstract void query(String name);//查
}

接口 TimeService

package com.oop.demo09;

public interface TimeService {
    void timer();
}

实现类

package com.oop.demo09;
//抽象类：单继承extends
//类可以实现多接口，通过  implements  接口
//实现了接口的类，就需要重写接口中的方法
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void add(String name) {
    }
    @Override
    public void delete(String name) {
    }
    @Override
    public void update(String name) {
    }
    @Override
    public void query(String name) {
    }
    @Override
    public void timer() {
    }
}

7. N种内部类

• 外部类与内部类

类

package com.oop.demo10;

public class Outer {

    private int id = 10;
    public void out(){
        System.out.println("这是外部类的方法");
    }

    public class Inner {
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //获得外部类的私有属性
        public void getID(){
            System.out.println(id);
        }
    }
}

运行文件

package com.oop;

import com.oop.demo10.Outer;

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.out();
        //通过外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getID();

    }
}

结果

这是外部类的方法
这是内部类的方法
10

• 运行文件中可有多个class

运行文件

package com.oop.demo10;

public class Outer {
    public static void main(String[] args) {
        
    }
}
//一个Java中可以有多个class文件，但是只能有一个public class文件
class A{
    public static void main(String[] args) {
        
    }
}

• 局部内部类

package com.oop.demo10;

public class Outer {
   //局部内部类
    public void method(){
        class Inner{
            public void in(){
                
            }
        }
    }

}

• 匿名类

package com.oop.demo10;

import com.oop.demo08.A;

public class Test {
    public static void main(String[] args) {
        Apple apple = new Apple();
        apple.eat();
        //没有名字初始化类
        new Apple().eat();//匿名对象的使用，不要保存实例

        UserService userService = new UserService() {   //也可以没有名字
            @Override
            public void hello() {
            }
        };
        
    }
}

class Apple{
    public void eat(){
        System.out.println("1");
    }
}
interface  UserService{   //接口
    void hello();
}