抽象类-接口-内部类

抽象类

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

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

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

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

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

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

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

接口

普通类：只有具体实现

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

接口：只有规范

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

注意点：

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

2. implement可以实现多个接口

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

 //interface 定义的关键字,接口都是需要实现类
public interface UserService {
    //接口中的所有定义其实都是抽象的（public  abstract都是默认，可以省略）
 
    public abstract void run(String name);
    void run();
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
 
}

public interface TimeService {
    void timer();
}

//类 可以实现接口 implements接口
//实现了接口的类，就需要重写接口中的方法~
public class UserServiceImp implements UserService,TimeService{
    @Override
    public void run(String name) {}

    @Override
    public void run() {}
 
    @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() {
    }
}

内部类

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

1.成员内部类

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

public class Application {
    public static void main(String[] args) {
 
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();//这是内部类的方法
        inner.getID();//10
    }
}

2.静态内部类

//无法获得非静态方法
public class Outer {
    private int 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);
//        }
    }
}

3.局部内部类

4.匿名内部类

public class Test {
    public static void main(String[] args) {
 
        //Apple apple = new Apple();实例化
 
        //没有名字初始化类，不用讲实例保存到变量中~
        new Apple().eat();
 
        UserService userService = new UserService(){
 
            @Override
            public void hello() {
            }
        };
    }
}
class Apple{
    public void eat(){
        System.out.println("1");
    }
}
 
interface UserService{
    void hello();
}