打卡15天（明天开始进阶！！冲啊！！！最近在想，我现在学的东西很有机会支持我未来真正想要做的工作，绝对不是编程，未来一辈子工作，我不想成为一直苦中作乐的人！）

抽象类

abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类

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

package oop.demo08;
​
​
//抽象类 abstract    类 extends   单继承   （接口可以多继承）
public abstract class Action {
​
    //abstravt，抽象方法只有方法名字，没有方法的实现
    public abstract void doSomething();
​
    //1.不能new抽象类，只能靠子类去实现它：约束
    //2。抽象类中可以写普通方法
    //3.抽象方法必须在抽象类中
    //抽象的抽象：约束
​
    //抽象的意义：提升开发效率
}
​

接口

普通类：只有具体的实现

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

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

• 接口就是个规范“如果你是。。。那必须。。。”

• 接口本质是契约，像法律，必须去遵守

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

作用：

1.约束，需要规范

2.定义一些方法，让不同的人实现 设定法律，使人遵守

3.public abstract 抽象方法

4.public static final 修饰属性，全局常量

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

6.implements可以实现多个接口

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

/*
package oop.demo09;
​
//interface 接口关键字
public interface UserService {
    //接口中的所有定义都是抽象的
    void run(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
​
}
​
------------------------------------------
package oop.demo09;
​
public interface TimeService {
    void timer();
}
​
 */
​
package oop.demo09;
​
//类 可以实现接口  implements 接口
//实现了接口的类，就需要重写接口中的方法
//多继承  利用接口实现多继承
public class UserServiceImpl implements UserService, TimeService {
    @Override
    public void timer() {
​
    }
​
    @Override
    public void run(String name) {
​
    }
​
    @Override
    public void delete(String name) {
​
    }
​
    @Override
    public void update(String name) {
​
    }
​
    @Override
    public void query(String name) {
​
    }
}

内部类

内部类就是在一个类的内部在定义一个类，A类中定义一个B类，那么B就是A的内部类，A就是B的外部类了

• 成员内部类

• 静态内部类

• 局部内部类

• 匿名内部类

package oop.demo10;
​
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);
        }
       */
​
    }
}
​
/*
package oop;
​
​
import oop.Demo06.Person;
import oop.Demo06.Student;
import oop.Demo06.Teacher;
import oop.demo10.Outer;
​
public class Application {
    public static void main(String[] args) {
        //new来实现
​
        Outer outer = new Outer();
​
        //通过外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
​
    }
}
​
 */

public class Outer {
​
​
    }
    
    //一个JAVA类中可以有多个class类，但是只能由一个public class类
    class A{
    
    }

---

package oop.demo10;
​
public class Outer {
    //局部内部类（方法里的变量，也是局部变量）
    public void method(){
        class Inner{
            public void in(){
                
            }
            
        }
    }
    }

---

package oop.demo10;
​
//面向对象是以思想为主
​
public class Test {
    public static void main(String[] args) {
        //没有名字去初始化类，这是匿名内部类（）不用将实例保存到变量中
        new Apple().eat();
        
        new UserService(){
            @Override
            public void hello() {
                
            }
        };
    }
​
​
}    
class Apple{
    public void eat(){
        System.out.println("1");
    }
}
interface UserService{
    void hello();
}