面向对象（3）

static关键字详解

//静态属性
public class student {
    private static int age; //静态变量  多线程
    private double socre;   //非静态变量

    public static void main(String[] args) {
        student s1 = new student();

        System.out.println(student.age); //类变量 可用
        //System.out.println(student.socre); 不可用

        System.out.println(s1.socre);   //通过对象调用 可用
        System.out.println(s1.age);
    }
}

//静态方法
public class teacher {
    public static void run(){

    }
    public void go(){

    }

    public static void main(String[] args) {
        new teacher().go(); //对象.方法
        run();  //直接方法
    }
}

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

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

//静态代码块
public class person {
    {
        System.out.println("匿名代码块");    //一般赋初始值
    }
    static {
        System.out.println("静态代码块");    //只执行一次 最先执行
    }

    public person() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        person p1 = new person();
        System.out.println("=============");
        person p2 = new person();
    }
}

注意 final是常量的修饰符。被final修饰的不能被继承了 就是没有子类了。

抽象类

abstract 提高开发效率。

为了被子类重写实现的。

但extends只能单继承。（接口可以多继承）。

public abstract class O抽象类 {
    /*
    1.只有方法名字 没有方法实现，只能靠子类去实现它。类似一个约束。
    2.抽象类中可以写普通方法。
    3.抽象方法必须在抽象类里
     */
    public abstract void doSomething();
}

接口的定义和实现

普通类：具体的实现

抽象类：具体的实现和规范的抽象方法

接口 ：只有规范。 约束和实现的分离：面向接口编程

接口本质：契约，制定后遵守。

声明类的关键字：class

声明接口的关键字：interface

接口都需要实现类

接口中所有定义的方法其实都是抽象的public abstract.

接口
public interface UserService {
    void add(String name);
    void dalate(String name);
    void update(String name);
    void query(String name);
}
接口
public interface TimeService {
    void timer();
}
实现类（快捷键生成）
public class UserServiceImpl implements UserService,TimeService {
    @Override
    public void timer() {

    }

    @Override
    public void add(String name) {

    }

    @Override
    public void dalate(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }
}

作用：

​ 1.是一种约束。定义一些方法让其他的人实现

​ 2.接口中默认的方法都是抽象的public abstract.

​ 3.接口中的常量默认都是public static final

​ 4.接口不能被实例化。因为接口中没有构造方法

5. implements可以实现多个接口

6. 必须要重写接口中的方法。

内部类

1.成员内部类

2.静态内部类

3.局部内部类

4.匿名内部类

就是在类的内部再定义一个类。

如：A类中定义一个类。B类相对于A类为内部类，A类相对于B类为外部类。

作用：内部类可获得外部类的私有属性。

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);
        }
    }
}

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