抽象类与接口

一、

1. 抽象类

• abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类。
• 抽象类中可以没有抽象方法，但是又抽象方法的类一定要声明为抽象类
• 抽象类，不能使用new关键字来创建对象，它是用来让子类继承的
• 抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的
• 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类

//定义一个抽象类
public abstract class Action{
	public abstract void doSomething();
	//抽象方法，只有方法，没有方法的实现
}

//子类继承抽象类
//在继承抽象类的时候，抽象类中的抽象方法必须要进行重写，否则无法运行
public class A extends Action{
	@override
	public void doSomething(){
		//方法体
	}
}

抽象类的意义：
由于抽象类中可以写抽象方法，也可以写普通方法。例如在创建游戏角色的时候，有些角色的初始值是一样的，就可以用普通方法写出来；而有些属性对于每个角色是不一样的，可以用抽象方法交给各个子类自己定义。
抽象类的作用：

• 不能new这个抽象类，只能靠子类去实现它：起约束作用
• 抽象类中可以写普通方法
• 抽象方法必须在抽象类中

2. 接口

• 普通类：只有具体实现
• 抽象类：具体实现和规范（抽象方法）都有！
• 接口：只有规范，自己无法写方法
• • 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”的思想。如果你是天使，则必须能飞。如果你是汽车，就必须能跑
• 接口的本质是契约，就像我们遵守制定好的法律一样
• OO的精髓，是对对象的抽象，最能体现这一点的就是接口，为什么我们讨论设计模式都只针对具备了抽象能力的语言（c++、java、c#），就是因为设计模式所研究的，实际上就是如何合理的去抽象。

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

1. 接口的定义

//interface：定义接口的关键字，接口都需要有实现类
public interface UserService{
	//接口中定义的属性，默认的是：public static final(常量)
	int age;

	//接口中的方法所有定义其实都是抽象的，默认的是public abstract
	// public abstract void run();
	void run();
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

public interface TimeService{
	void timer();
}

2. 一个类可以实现多个接口

//一个类可以实现多个接口
//实现了接口的类，就需要重写接口中的方法
public class UserServiceImpl implements UserService,TimeService{
	@ovrride 
	public void run(){

	}

	@ovrride 
	 @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() {

    }
}

接口的作用：
3. 起约束作用
4. 定义了一些方法，让不同的人实现
5. 方法都是public abstract
6. 常量都是 public static final
7. 接口不能被实例化，因为接口中没有构造方法
8. implements 可以实现多个接口，必须要重写接口中的方法
二、内部类

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

1. 成员内部类

public class Outer{
	private in id = 10;
	public void out(){
		System.out.println("这是外部类的方法");
	}
	 //内部类
	 public class Inner{  
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //获得外部类的私有属性或方法
        public void getID(){
            System.out.println(id);
        }
        public void getMethod(){
            out();
        }
}

application：

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

2. 静态内部类 (静态内部类无法访问到非静态属性)

public class Outer{
    private in id = 10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    //静态内部类
    public static class Inner{  
        public void in(){
            System.out.println("这是外部类的方法");
        }
        //无法获得外部类的非静态私有属性或方法
        public void getID(){
            System.out.println(id);
        } //报错
        
        public void getMethod(){
            out();
        }	//报错
    }
}```
3. 局部内部类
```java
public class Outer{
    
    //局部内部类
    public void method(){
        class Inner{
            public void in(){
                
            }
        }
    }
}

4. 匿名内部类

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();
}