（三）面向对象编程（OOP）

（三）面向对象编程（OOP）

static关键字

//static 静态的
public class Student {

    private static int age;//静态的变量  多线程
    private double score; //非静态的变量

    public void run(){}

    public static void go(){}
    public static void main(String[] args) {
        Student student = new Student();
        student.score = 90;
//        student.age=19;
//        Student.age = 18;
        System.out.println(student.score);
        System.out.println(Student.age);

        student.run();
        go();
        age=12;
    }
}

//final：表示最终，不可被继承
public final class Person {
    public static int age = 10;
    //2：赋初值~
    {
        age = 2;
        System.out.println("匿名代码块");
    }
    //1：只执行一次~
    static {
        age = 1;
        System.out.println("静态代码块");
    }
    //3
    public Person() {
        System.out.println("构造方法");
    }

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

//也可静态导入包的方式
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);
        System.out.println(Math.abs(-1.2));
    }
}

抽象类

//abstract 抽象类：类 extends： 单继承~  （接口可以多继承）
public abstract class Action {
    public Action() {
        System.out.println("抽象类Action的构造器被调用~");
    }

    //约束~有人帮我们实现~
    //abstract 抽象方法，只有方法名，没有方法的实现
    public abstract void doSomething();

    //1、不能new这个抽象类，只能靠子类去实现它：约束！
    //2、抽象类中可以写普通的方法~
    //3、抽象方法必须在抽象类中~
    //抽象的抽象：约束~

    //存在构造器
    //存在的意义   抽象出来~  提高开发效率

}

//抽象类的所有方法，继承了它的子类，都必须要实现它的方法~
// 除非这个类也是抽象的类
public class A extends Action{
    @Override
    public void doSomething() {
        System.out.println("A doSomething");
    }

    public static void main(String[] args) {

        A a = new A();

        a.doSomething();
    }
}

接口的定义与实现

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


public interface TimeService {
    void timer();
}


//抽象类： 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. 定义一些方法，让不同的人实现~ 10 ----> 1
3. public abstract
4. public static final
5. 接口不能被实例化_{，接口中没有构造方法}
6. implement可以实现多个接口
7. 必须要重新接口中的方法~

N种内部类

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

    //如果这个类是static，则将不能获取id和外面的方法，因为static是和类一起先加载的
    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //获取外部类的私有属性和方法~
        public void getID(){
               System.out.println(id);
               out();
        }
    }

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

//一个java类中可以有多个class类，但是只能有一个public class
class A{

}


//测试类
public class Applicantion {

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

}

public class Test {
    public static void main(String[] args) {
        //没有名字初始化类，不用将实例保存到变量中！
        new Apple().eat();

        UserService userService = new UserService() {
            @Override
            public void hello() {
            }
        };
    }
}

class Apple{
    public void eat(){
        System.out.println("吃苹果");
    }
}

interface UserService{
    void hello();
}