【狂神说Java】2021-03-18学习笔记：面向对象

面向对象编程（OOP）

1.初识面向对象

2.方法回顾和加深

3.对象的创建分析

4.面向对象的三大特性

5.抽象类和接口

6.内部类及OOP实战

初识面向对象

面向过程&面向对象

面向过程思想（线性思维）：

步骤清晰简单，第一步做什么，第二步做什么……

面对过程适合处理一些较为简单的问题

面向对象思想（分类思维）：

物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。

面向对象适合处理复杂的问题，适合处理需要多人协作的问题！

对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

什么是面向对象

面向对象编程（Object-Oriented Programming，OOP）

面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。

抽象（其实就是把共同研究的单独拎出来）

三大特征：

封装：把数据包装起来

继承：子类继承父类

多态：同一事物有多种形态

从认识论角度考虑：先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。

先有的一堆人，然互有一群人都是教师，教师是抽象出来的。

从代码运行角度考虑是先有类后有对象。类是对象的模板。

先有个person的模板，然后再new好多人

方法回顾和加深

方法的定义：修饰符、返回类型、break（跳出switch，结束循环）和return（返回一个值）的区别、方法名、参数列表、异常抛出

package com.oop;
//Demo01  就是个类
public class Demo01 {
    //main方法（）一个真正的程序中，只有一个main()方法
    public static void main(String[] args) {
    }

    /*
    修饰符 返回值类型  方法名（...）{
        //方法体
        return 返回值;
    }
     */
    
    //return 结束方法，返回一个结果，结果可空可不空
    public String sayHello(){
        return "Hello,Zhao Daye!";
    }
    public void print(){
        return;
    }
    public int max(int a,int b){
        return a>b ? a:b;  //三元运算符
    }    
}

方法的调用：静态方法、非静态方法、形参和实参、值传递和引用传递、this关键字

//静态方法   static
//非静态方法
static后续会减少使用，为了更好的封装，避免直接被外部调用

package com.oop;

public class Demo02 {

    public static void main(String[] args) {
        //实例化这个类  new
        //对象类型   对象名 = 对象值；
        Student student = new Student();
        student.say();
    }
    //和类一起加载的
    public static void a(){
        b();   //报错，因为此时，a存在，但是b还没有被实例化
    }
    
    //类实例化 之后才存在的
    public void b(){
    }
}



package com.oop;
//学生类
public class Student {

    //非静态方法
    public void say(){
        System.out.println("学生说话了！");
    }
}

package com.oop;

//值传递
public class Demo04 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);

        Demo04.change(a);
        System.out.println(a);
    }

    public static void change(int a) {
        a = 10;
    }

}
/*运行结果：
1
1

Process finished with exit code 0
*/

package com.oop;

//引用传递：对象，本质还是值传递
public class Demo05 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);  //null

        Demo05.change(person);  
        System.out.println(person.name);  //daye
    }

    public static void change(Person person) {
        //person是一个对象：指向的-》Person person = new Person();这是一个具体的人，可以改变属性！
        person.name = "daye";
    }
}

//定义了一个Person类，有一个属性：name
class Person {
    String name;  //默认值是null
}
/*运行结果：
null
daye

Process finished with exit code 0
*/

类和对象的关系

类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是 并不能代表某一个具体的事物。

动物、植物、手机、电脑……

Person类、Pet类、Car类，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为

对象是抽象概念的具体实例。

张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例。

能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念

对象的创建分析

创建与初始化对象

使用new关键字创建对象

使用new关键字创建的时候，除了分配内存空间外，还会给创建好的对象进行默认的初始化，以及对类中构造器的调用。

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：

1.必须和类的名字一样

2.必须没有返回类型，也不能写void

package com.oop.demo02;
//学生类
public class Student {
    //属性：字段
    String name;
    int age;

    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }
}



package com.oop.demo02;
//一个项目里应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        //类是抽象的，它需要实例化
        //类实例化后会返回一个自己的对象！
        //student对象就是一个Student类的具体实例！

        Student xiaoming = new Student();//这步就是在实例化
        Student xiaohong = new Student();//这步也是在实例化

        xiaoming.name="小明";
        xiaoming.age=15;

        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);

    }
}
/*
小明
15

Process finished with exit code 0
*/

构造器

构造器必须掌握

package com.oop.demo02;

public class Application {
    public static void main(String[] args) {
        //new 实例化了一个对象
        Person xiaozhang =new Person();   //第一步|也没有报错，运行结果为：null，说明存在一个空的方法
        System.out.println(xiaozhang.name);

        Person person = new Person("zhaodaye");   //第四步|
        System.out.println(person.name);
    }
}


package com.oop.demo02;

public class Person {
    //一个类即使什么都不写，它也会存在一个方法
    //显示的定义一个构造器
    String name;

    //1.使用new关键字，本质是在调用构造器
    //2.用来初始化值
    public Person() {     //第二步|
    }

    //有参构造：一旦定义了有参构造，无参就必须显示定义
    public Person(String name) {    //第三步|
        this.name = name;
    }
}

/*
构造器：
1.和类名相同。2.没有返回值
作用：
1.new本质是在调用构造方法
2.初始化对象的值
注意点：
定义有参构造之后，如果想使用无参构造，必须要做的一件事是：显示的定义一个无参的构造

快速构造一个构造器的快捷键：Alt+Insert
* */


/*运行结果：
null
zhaodaye

Process finished with exit code 0
*/

复盘：

1.类与对象

类是一个抽象的模板，对象是一个具体的实例

2.方法

定义、调用

3.对象的引用

引用类型：基本类型（8大）

对象是通过引用来操作的：栈–>堆（地址）

4.对象的属性

字段Field 成员变量

默认初始化：

数字：0 0.0

char：u0000

boolean：false

引用：null

修饰符 属性类型 属性名=属性值

5.对象的创建和使用

-必须使用new关键字创造对象，需要用到构造器 Person daye = new Person();

-对象的属性 daye.name

-对象的方法 daye.eat()

6.类：

静态的属性 属性

动态的行为 方法

面向对象的三大特性

封装、继承、多态

封装

该露的露，该藏得藏

我们程序要追求“高内聚，低耦合”。

高内聚:就是类的内部数据操作细节自己完成，不允许外部干涉；

低耦合：仅暴露少量的方法给外部使用

封装（数据的隐藏）

通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这成为信息隐藏。

属性私有，get/set

封装的意义：
1.提高程序的安全性，保护数据
2.隐藏代码的细节，比如：以下年龄的设置
3.统一接口
4.提高系统的可维护性

package com.oop;

import com.oop.demo03.Pet;

public class Application {
    public static void main(String[] args) {
        Pet pet = new Pet();
//        pet.name="wangcai";    报错

        pet.setName("Leo");
        System.out.println(pet.getName());

        pet.setAge(999);
        System.out.println(pet.getAge());
    }
}




package com.oop.demo03;

public class Pet {
    //属性私有  private
    private String name;  //名字
    private int age;   //年龄

    //提供一些可以操作这个属性的方法
    //提供一些public的get、set

    //get【获得】这个数据
    public String getName() {

        return this.name;
    }

    //set给这个数据【设置】值
    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age > 20 || age < 0) {
            this.age = 3;
        } else {
            this.age = age;
        }
    }
}
/*
Leo
3

Process finished with exit code 0
*/

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

extends的意思是“扩展”。子类是父类的扩展。

Java中类只有单继承，没有多继承！（一个儿子只能有一个父亲，一个父亲可以有多个儿子！）

继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。

继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。

子类和父类之间，从意义上讲应该具有“is a ”的关系。比如：旺财是只狗。

package com.oop.demo04;
//在java中，所有的类，都默认直接或间接继承object
//Person人：父类
public class Person {
    public int money=10_0000_0000;
    private int age=40;
    public void say(){
        System.out.println("说了一句话");
    }
}
--------------------------------------------------
package com.oop.demo04;
//学生 is 人：派生类或子类
//子类继承了父类，就会拥有父类的全部方法！
public class Student extends Person{
}

==================================================
package com.oop;

import com.oop.demo04.Student;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();                    //运行结果：说了一句话
        System.out.println(student.money);//运行结果：1000000000
//      System.out.println(student.age);  报错！因为age在Person中是private私有的
    }
}
/*
说了一句话
1000000000

Process finished with exit code 0
*/

ctrl+H快捷键：可以查看该类继承的上下关系

public、protected、default（相当于不写）、private

优先级由高到低

所有类都直接或间接继承object类

super

package com.oop.demo04;
//在java中，所有的类，都默认直接或间接继承object
//Person人：父类
public class Person {
    protected String name="zhaodaye";
    }
}
--------------------------------------------------
package com.oop.demo04;
//学生 is 人：派生类或子类
//子类继承了父类，就会拥有父类的全部方法！
public class Student extends Person{
    private String name="menggaga";
    
    public void test(String name){
        System.out.println(name);   //传参进来的
        System.out.println(this.name);   //该Student中的
        System.out.println(super.name);  //Student的父类中的
    }
}
====================================================
package com.oop;

import com.oop.demo04.Student;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.test("wangfifi");
    }
}
/*
wangfifi    //传参进来的
menggaga    //该Student中的
zhaodaye    //Student的父类中的

Process finished with exit code 0
*/

package com.oop.demo04;
//在java中，所有的类，都默认直接或间接继承object
//Person人：父类
public class Person {
    public void print(){
        System.out.println("Person");
    }
    /*
    private void print(){}
    就会报错，因为私有的东西无法被继承！
    */
}
----------------------------------------------------------
package com.oop.demo04;
//学生 is 人：派生类或子类
//子类继承了父类，就会拥有父类的全部方法！
public class Student extends Person{
    public void print() {
        System.out.println("Student");
    }

    public void test2(){
        print();   //当前Student中的方法
        this.print();   //当前Student中的方法
        super.print();   //当前Student的父！类！中的方法
    }
}
============================================================
package com.oop;

import com.oop.demo04.Student;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.test2();
    }
}
/*
Student
Student
Person

Process finished with exit code 0
*/

package com.oop.demo04;

public class Person {
    public Person() {
        System.out.println("Person无参执行了");
    }
}
--------------------------------------------------
package com.oop.demo04;

public class Student extends Person{
    public Student() {
        //~
        System.out.println("Student无参执行了");
    }
}
==================================================
package com.oop;

import com.oop.demo04.Student;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
    }
}
/*
Person无参执行了
Student无参执行了

Process finished with exit code 0
*/
/*
是因为，实际上在Student类的~处，有一行隐藏的代码↓，这行代码调用了父类的无参构造
super();  //调用父类的构造器，必须要在子类构造器的第一行
*/

super注意点：

1.super 调用父类的构造方法，必须在构造方法的第一个

2.super 必须只能出现在子类的方法或者构造方法中

3.super 和 this 不能同时调用方法

VS

this：

代表的对象不同：this代表本身调用这个对象，super代表父类对象的应用

前提不同：this在没继承的时候也可以使用，super只能在继承条件下才可以使用

构造方法的区别：this（）是本类的构造，super（）是父类的构造

※方法重写

重写都是方法的重写，与属性一分钱关系都没有

package com.oop.demo05;

public class B {

    public static void test(){
        System.out.println("B=>test()");
    }
}
----------------------------------------------
package com.oop.demo05;

public class A extends B{

    public static void test() {
        System.out.println("A=>test()");
    }
}
===============================================
package com.oop;

import com.oop.demo05.A;
import com.oop.demo05.B;

public class Application {
    public static void main(String[] args) {
        //方法的调用只和左边 定义的数据类型有关
        A a = new A();
        a.test();

        //父类的引用指向了子类
        B b = new A();
        b.test();

    }
}
/*
A=>test()
B=>test()

Process finished with exit code 0
*/

package com.oop.demo05;

public class B {
    public void test(){
        System.out.println("B=>test()");
    }
}
-----------------------------------------------
package com.oop.demo05;

public class A extends B{
    //Override 重写
    @Override   //注解：有功能的注释！
    public void test() {
        System.out.println("A=>test()");
    }
}
===============================================
package com.oop;

import com.oop.demo05.A;
import com.oop.demo05.B;

public class Application {
    public static void main(String[] args) {
        //方法的调用只和左边 定义的数据类型有关
        A a = new A();
        a.test();
        //父类的引用指向了子类
        B b = new A();
        b.test();
    }
}
/*
A=>test()
A=>test()

Process finished with exit code 0
*/

两段不同的原因是：

后一段b是A new出来的对象，因此调用了A的方法

没有static时，b调用的是对象的方法，而b是用A类new的

有static时，b调用了B类的方法，因为b是用b类定义的

因为静态方法是类的方法，而非静态是对象的方法

---

重载是同一类里，方法名相同，参数类型不同。

重写是子父类之间，子类重写父类的方法，子类重写父类的方法。

---

子类要重写父类方法，父类方法不一定要public，只要子类重写方法的权限修饰符不比父类更严格就行

---

重写：需要有继承关系，子类重写父类的方法！

1.方法名必须相同

2.参数列表必须相同

3.修饰符：范围可以扩大但不能缩小：public->protected->default->private

4.抛出的异常，范围可以被缩小，但不能扩大：ClassNotFoundException->Exception（大）

---

重写，子类的方法和父类必须一致：方法体不同

---

为什么需要重写

父类的功能子类不一定需要，或者不满足

Alt+Insert：override重写的快捷键

多态

实现动态编译，使程序可扩展性增强

即同一方法可以根据发送对象的不同而采用多种不同的行为方式

一个对象的实际类型的确定的，但可以指向对象的引用类型有很多（父类，有关系的类）

package com.oop.demo06;

public class Person {
    public void run(){
        System.out.println("run");
    }
}
---------------------------------------
package com.oop.demo06;

public class Student extends Person{
}
=======================================
package com.oop;

import com.oop.demo06.Person;
import com.oop.demo06.Student;

public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //可以指向的引用类型就不确定了

        //可以指向的引用类型不确定：父类的引用指向子类
        Student s1 = new Student();
        Person s2 = new Student();

        s2.run();
    }
}
/*
run

Process finished with exit code 0
*/

package com.oop.demo06;

public class Person {
    public void run(){
        System.out.println("run");
    }

}
---------------------------------------------
package com.oop.demo06;

public class Student extends Person{
    @Override
    public void run() {
        System.out.println("son run");
    }
}
=============================================
package com.oop;

import com.oop.demo06.Person;
import com.oop.demo06.Student;

public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //可以指向的引用类型就不确定了

        //可以指向的引用类型不确定：父类的引用指向子类
        Student s1 = new Student();
        Person s2 = new Student();

        s2.run();  //子类一旦重写了父类的方法，就执行子类的方法
        s1.run();
    }
}
/*
son run
son run

Process finished with exit code 0
*/

多态存在的条件：

• 有继承关系

• 子类重写父类方法

• 父类引用指向子类对象

注意：

1.多态是方法的多态，属性没有多态性

2.父类和子类，要有联系，比如Person转String就不行，否则会报类型转换异常！ClassCastException！

3.存在条件：继承关系，方法需要重写，父类的引用指向子类对象！ Father f1=new Son();

---

不能被重写的方法：

1.static方法，属于类，它不属于实例

2.final 位于常量池中，是常量

3.private方法

---

instanceof （类型转换）引用类型

判断一个对象是什么类型，判断两个类之间有没有父子关系

• 同一类下，父亲和自己为true，儿子为false
• 不同类下，为false

package com.oop.demo06;

public class Person {
    
}
----------------------------------------
package com.oop.demo06;

public class Teacher extends Person{

}
----------------------------------------
package com.oop.demo06;

public class Student extends Person{

}
=========================================
package com.oop;

import com.oop.demo06.Person;
import com.oop.demo06.Student;
import com.oop.demo06.Teacher;

public class Application {
    public static void main(String[] args) {
        Object o = new Student();
        //Object > String
        //Object > Person > Teacher
        //Object > Person > Student

        System.out.println(o instanceof Student);  //true
        System.out.println(o instanceof Person);  //true
        System.out.println(o instanceof Object);  //true
        System.out.println(o instanceof Teacher);  //false
        System.out.println(o instanceof String);  //false
    }
}
/*运行结果：
true
true
true
false
false

Process finished with exit code 0
*/
===================================================
package com.oop;

import com.oop.demo06.Person;
import com.oop.demo06.Student;
import com.oop.demo06.Teacher;

public class Application {
    public static void main(String[] args) {
        Object o = new Person();
        //Object > String
        //Object > Person > Teacher
        //Object > Person > Student

        System.out.println(o instanceof Student);  //false
        System.out.println(o instanceof Person);  //true
        System.out.println(o instanceof Object);  //true
        System.out.println(o instanceof Teacher);  //false
        System.out.println(o instanceof String);  //false
    }
}
/*
false
true
true
false
false

Process finished with exit code 0
*/
===============================================================
package com.oop;

import com.oop.demo06.Person;
import com.oop.demo06.Student;
import com.oop.demo06.Teacher;

public class Application {
    public static void main(String[] args) {
        Object o = new Student();
        //Object > String
        //Object > Person > Teacher
        //Object > Person > Student

        System.out.println(o instanceof Student);  //true
        System.out.println(o instanceof Person);  //true
        System.out.println(o instanceof Object);  //true
        System.out.println(o instanceof Teacher);  //false
        System.out.println(o instanceof String);  //false

        System.out.println("==============");
        Person p = new Student();
        System.out.println(p instanceof Student);  //true
        System.out.println(p instanceof Person);  //true
        System.out.println(p instanceof Object);  //true
        System.out.println(p instanceof Teacher);  //false
//      System.out.println(p instanceof String);  //编译就报错，因为Person与String是同级

        System.out.println("==============");
        Student s = new Student();
        System.out.println(s instanceof Student);  //true
        System.out.println(s instanceof Person);  //true
        System.out.println(s instanceof Object);  //true
//        System.out.println(s instanceof Teacher);  //编译就报错
//        System.out.println(s instanceof String);  //编译就报错
    }
}
/*
true
true
true
false
false
==============
true
true
true
false
==============
true
true
true

Process finished with exit code 0
*/

package com.oop.demo06;

public class Person {
    public void run(){
        System.out.println("run");
    }
}
------------------------------------------
package com.oop.demo06;

public class Student extends Person{
    public void go(){
        System.out.println("go");
    }

}
=============================================
package com.oop;

import com.oop.demo06.Person;
import com.oop.demo06.Student;

public class Application {
    public static void main(String[] args) {
        //类型之间的转化：父（高）  子（低）

        //高               低      此处低转高不需要强制转换
        Person obj = new Student();
//        obj.go();   报错

      //student将这个对象转换为Student类型，我们就可以使用Student类型的方法了
        Student student = (Student)obj;
        student.go();     //这两行相当于((Student)obj).go();
        Person person = student;
    }
}


/*
1.父类引用指向子类的对象。
2.把子类转换为父类，向上转型，不用强制转换。
3.把父类转换为子类，向下转型，需要强制转换。
4.方便方法的调用，减少重复的代码！使代码变得简洁。
*/

static关键字

package com.oop.demo07;
//static:在类中使用就是修饰成员变量->静态属性，在方法中就是成员方法->静态方法

public class Student {

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

    public static void main(String[] args) {
        
        Student s1 = new Student();
        double score = s1.score;
        int age = s1.age;

        System.out.println(Student.age); 
        //如果是静态的变量，推荐使用类名去点
//      System.out.println(Student.score);  报错
        System.out.println(s1.age);
        System.out.println(s1.score);
    }
}
/*
0
0
0.0

Process finished with exit code 0
*/

加了static就是静态的，引用时用类名点，用new后名点都可以。不加就只能用new后名点。

package com.oop.demo07;

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();
    }
}
/*
静态代码块
代码块（匿名）
构造方法
=================
代码块（匿名）
构造方法

Process finished with exit code 0
*/

执行的时候，按照静态代码块>代码块>构造方法

但是第二次，静态代码块就不执行了。

package com.oop.demo07;
public class Test {
    public static void main(String[] args) {
        System.out.println(Math.random());
    }
}

//当用static导入包后，可直接用
package com.oop.demo07;

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

public class Test {

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

final一旦写在父类，就不能被继承了。final俗称“断子绝孙”

抽象类和接口

抽象类

abstract修饰符可以用来修饰方法，也可以修饰类，

如果修饰方法，那么该方法就是抽象方法；

如果修饰类，那么该类就是抽象类。

抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。

抽象类，不能使用new关键字来创建对象，它是用来让子类继承的。

抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。

子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。

package com.oop.demo08;
//abstract  抽象类
public abstract class Action {
    //约束 有人帮我们实现
    //abstract ，抽象方法，只有方法名字，没有方法的实现！
    public abstract void doSomething();
}
==========================================================
package com.oop.demo08;
//extends只能单继承，如果想在子类多继承->接口可以多继承
//想要继承abstract的父类，子类也必须是abstract
public abstract class A extends Action{
}

抽象类：

1.不能new这个抽象类，只能靠子类去实现它（约束）

2.抽象类中可以写普通的方法

3.抽象方法必须在抽象类中

也就是：抽象的抽象

抽象类的意义：抽象类就是来实现封装，多态地增强代码的可拓展性。提高开发效率。

接口

普通类：只有具体实现

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

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

接口就是规范，定义的是一组规则，体现了现实世界中”如果你是…则必须能…“的思想。

接口的本质是契约，就像是我们人间的法律一样。制定好后大家都遵守。

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

-我们为什么讨论设计模式都只针对具备了抽象能力的语言（比如C++、java、c#等）？

-就是因为设计模式所研究的，实际上就是如何合理地去抽象。

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

package com.oop.demo09;

//interface 定义的关键字,接口都需要有实现类
public interface UserService {
    //接口中的所有定义其实都是抽象的  public
    //public abstract void run(String name);可直接写成
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);

    //接口里定义的属性都是静态的常量
    //public static final int AGE = 99;
    //几乎没人在接口里定义常量！
    int AGE = 99;
}
-------------------------------------------------------
package com.oop.demo09;

public interface TimeService {
    void timer();
}

=====================================================
package com.oop.demo09;

//抽象类:extends
//类可以通过implements关键字实现接口
//实现了接口的类，就需要重写接口中的方法

//java是单继承的，但是可以利用接口实现多继承
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) {

    }
}

接口作用：

1.约束

2.定义一些方法，让不同的人实现

3.接口中的方法都是public abstract

4.接口中的变量都是public static final

5.接口不能被实例化，因为接口中没有构造方法

6.implements可以实现多个接口

7.implements后必须要重写接口中的方法

内部类及OOP实战

内部类就是在一个类的内部定义一个类，比如，A类中定义了一个B类，那么B类相对于A类来说就成为内部类，而A类相对于B类就是外部类了。

种类：1.成员内部类 2.静态内部类 3.局部内部类 4.匿名内部类

package com.oop.demo10;
public class Outer {
    private int id = 34;
    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) {

        //外部类通过new去实现
        Outer outer = new Outer();

        //通过外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.getID();
    }
}
/*
34

Process finished with exit code 0
*/

package com.oop.demo10;

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

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

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

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

interface UserService{
    void hello();
}

参考视频：【狂神说Java】Java零基础学习视频通俗易懂