Day12 java面向对象：static、抽象类、接口、内部类

static

public class Student {
    private static int age;//静态的变量 多线程！
    private double score;//非静态的变量

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

        System.out.println(Student.age);
        System.out.println(s1.score);
        System.out.println(s1.age);

        go();
    }

    public static void go() {

    }

    public void run() {

    }

    //1；首先执行，只执行一次
    static {
        //静态代码块
        System.out.println("静态代码块");
    }
    //2：第二执行
    {
        //代码块（匿名代码块）
        System.out.println("匿名代码块");
    }
    //3：第三执行
    public Student() {
        System.out.println("构造方法");
    }
}

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

通过final修饰的类无法被继承。

抽象类

//abstract 抽象类：类extends:单继承。 （接口可以多继承）
public abstract class Action {

    //约束-有人帮我们实现
    //abstract,抽象方法，只有方法名字，没有方法的是实现。
    public abstract void doSomeThing();

    //1.不能new这个抽象类，只能靠子类来是实现它。
    //2.抽象方法必须在抽象类中。
    //3.抽象类中可以写普通方法。
    //4.抽象类不能直接new出来，但是存在构造器。
    //5.存在的意义：将公有属性抽象出来，节省代码开发，提高开发效率。
}

抽象类存在构造器吗？

有，抽象类可以声明并定义构造函数。因为你不可以创建抽象类的实例，所以构造函数只能通过构造函数链调用（Java中构造函数链指的是从其他构造函数调用一个构造函数），例如，当你创建具体的实现类。现在一些面试官问，如果你不能对抽象类实例化那么构造函数的作用是什么？好吧，他可以用来初始化抽象类内部声明的通用变量，并被各种实现使用。另外，即使你没有提供任何构造函数，编译器将为抽象类添加默认的无参数的构造函数，没有的话你的子类将无法编译，因为在任何构造函数中的第一条语句隐式调用super（），Java中默认超类的构造函数。

接口

//抽象的思维~Java
//interface是定义接口的关键字,接口都需要有实现类
public interface UserService {
    //常量
    public static final int age=99;
    //接口中的所有定义其实都是抽象的 public
    public static void run(String name) {
    }
    //默认就是public static 的
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

public interface TimeService {
    void timer();
}

package com.jyw.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() {

    }
}

接口的作用：

1. 是一个约束。
2. 定义一个抽象方法，让不同的人实现。
3. 用public abstract来修饰方法。
4. 用public static final来修饰常量。
5. 接口不能实例化，接口中没有构造方法。
6. implements 可以实现多个接口。
7. 必须要重写接口中的方法。

内部类

public class Outer {
    private int id = 10;

    public void out() {
        System.out.println("这是外部内的方法。");
    }

    //成员内部类
    public class Inter {
        public void in() {
            System.out.println("这是内部类的方法。");
        }

        //获取外部类的私有属性
        public void getId() {
            System.out.println(id);
        }
    }

    //静态内部类
    public static class StaticInter {
        public void in() {
            System.out.println("这是内部类的方法。");
        }

        //获取外部类的私有属性
        public void getId() {
            //System.out.println(id);//静态类优先加载，所以无法获取id
        }
    }

    //局部内部类:在方法里面写的类
    public void method() {
        class MethodInner {
        }
    }

    public static void main(String[] args) {
        //匿名内部类：没有名字
        //没有名字初始化类，不用将实例保存到变量中
        new Apple().eat();
        UserService1 userService1 = new UserService1() {
            @Override
            public void hello() {
            }
        };
    }
}

//一个java类中可以有多个class文件，但是只能有一个public class
class Apple {
    public void eat() {
        System.out.println("eat");
    }
}

interface UserService1 {
    void hello();
}

public class Aplication {
    public static void main(String[] args) {
        //实例化外部类
        Outer outer = new Outer();
        //通过外部类实例化内部类~
        Outer.Inter inter = outer.new Inter();
        inter.in();
    }
}