面向对象编程

1. 初时面向对象
2. 方法回顾和加深
3. 对象的创建分析
4. 面向对象三大特征
5. 抽象类和接口
6. 内部类和OOP实战

4. 面向对象的三大特征

static关键字详解

public class Person {
    //2：赋初始值
    {
        //代码块（匿名代码块）
        System.out.println("匿名代码块");
    }
    //1.只执行一次
    static {
        //静态代码块
        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();
    }
}
/*
输出结果为：
静态代码块
匿名代码块
构造方法
====================
匿名代码块
构造方法
 */

package com.oop.Demo07;
//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 s1 = new Student();

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

5. 抽象类和接口

抽象类

package com.oop.Demo08;
//abstract 抽象类：类  extends:单继承     （接口可以实现多继承）
public abstract class Action {
    //约束，有人帮我们实现~
    //abstract,抽象方法，只有方法名字，没有方法的实现
    public abstract void doSomething();
    //1.不能new这个抽象类，只能靠子类来实现它；约束！
    //2.抽象类中可以写普通方法
    //3.抽象方法必须在抽象类中
    //抽象的抽象：约束

    //思考题：  new不可以，存在构造器么？
        //存在的意义  抽象出来，提高开发效率
}

package com.oop.Demo08;
//抽象类的所有方法，继承类它的子类，都必须实现它的方法
public class A extends Action{
    @Override
    public void doSomething() {
    }
}

接口

• 普通类：只有具体的实现

• 抽象类：具体实现和规范（抽象方法）都有

• 接口：只有规范，自己无法写方法~专业的约束！约束和实现分离：面向接口编程

• 接口就是规范，体现了现实世界中“如果你是...则必须能...”的思想，如果你是天使，则必须能飞。如果你是汽车，则必须能跑......

• 接口本质是锲约，就下岗我们人间的法律一样，指定好后大家都要遵守

• OO的精髓，是对对象的抽象，最能体现这一点的就是接口

• 声明类的关键字是class，声明接口的关键字是interface

package com.oop.Demo09;
//interface 定义关键字
public interface UserService {
    //常量
    int age = 99;  //即为public static final int age = 99；
    //接口中的所有定义其实都是抽象的public  abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

package com.oop.Demo09;
//类  可以实现接口 通过implements 接口
//实现了接口的类，就必须要重写接口中的方法
//多继承~利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void timer() {

    }

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }
}

package com.oop.Demo09;

public interface TimeService {
    void timer();//可以直接写成左边的样子省略public（public void timer();）
}

接口作用：
    1.约束
    2.定义一些方法，让不同的人实现
    3.方法都是public  abstract
    4.public static final
    5.接口不能被实例化~，接口中没有构造器
    6.接口是可以实现多继承  用implements
    7.继承后必须要重写接口中的方法