JavaSE13-抽象类、接口和各种内部类

一、抽象类
二、接口
三、内部类

一、抽象类

抽象，关键字是abstract
有abstract修饰的类是抽象类，有abstract修饰的方法是抽象方法
不能new这个抽象类，只能靠子类去实现它
抽象类中可以写普通的方法
抽象方法必须写在抽象类中

//抽象类（约束），继承它的子类必须实现（重写）抽象方法
public abstract class Action {

    //抽象方法，只有方法名，没有实现
    public abstract void doSth();

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

它的子类

public class Action2 extends Action{

    @Override
    public void doSth() {
        System.out.println("dosomething");
    }
}

二、接口

普通类：具体实现，关键字 class
抽象类：规范（抽象方法）和具体实现，关键字abstract class
接口：只有规范，关键字 interface，约束和实现分离
必须要实现接口中的方法
接口是就是规范，定义的是一组规则，它的本质是契约
面向对象的精髓，是对对象的抽象，最能体现在这一点的就是接口
类一般是单继承，利用接口可以实现多继承（在一个类中实现多个接口）
接口不能被实例化，没有构造方法

接口UserService

//接口都需要有实现类
public interface UserService {
    //接口中的所有定义其实都是抽象的，即默认 public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);

		//默认public abstract final，一般不会在接口中定义属性
    int AGE = 0;
}

接口TimeService

public interface TimeService {
    void time();
}

实现类()

//可以在一个实现中实现多个接口，多继承
public class UserServiceImpl implements UserService,TimeService{

    //alt+insert -->实现方法
    @Override
    public void add(String name) {
				...
    }

    @Override
    public void delete(String name) {
				...
    }

    @Override
    public void update(String name) {
				...
    }

    @Override
    public void query(String name) {
				...
    }

    //TimeService接口的实现
    @Override
    public void time() {
				...
    }
}

三、内部类

内部类就是在一个类中再定义一个类。

成员内部类
静态内部类
局部内部类
匿名内部类

public classDemo04 {
public static voidmain(String[] args) {
//匿名内部类,没有名字初始化,不用将实例保存到变量中
newApple().eat();

        UserService userService =newUserService() {
            @Override
public voidhello() {
                System.out.println("hello");
            }
        };
    }
}

//一个java类文件中可以写多个类，但只能有一个public类
//与写在不同类文件中使用基本相同
classApple{
public voideat(){
        System.out.println("eat");
    }
}

interfaceUserService{
voidhello();
}

1.成员内部类

类Demo01

//外部类
public class Demo01 {
    private int id;
    public void out(){
        System.out.println("这是外部类的方法");
    }

		//成员内部类
    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }

        //内部类可以访问外部类的私有属性
        public void getId(){
            System.out.println(id);
        }
    }
}

类Application

public class Application {
    public static void main(String[] args) {
        //通过外部类实例化内部类
        Demo01 outer = new Demo01();
        Demo01.Inner i1 = outer.new Inner();
        i1.in();  //这是内部类的方法
        i1.getId();  //0
    }

2.静态内部类

类Demo02

public class Demo02 {
    private int id;
    public void out(){
        System.out.println("这是外部类的方法");
    }
		//静态内部类
    public static class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
    }
}

类Application

public class Application {
    public static void main(String[] args) {
        //通过外部类实例化内部类
        Demo02 outer = new Demo02();

    }

3.局部内部类

类Demo03

public class Demo03 {
    
    public void method(){
        
        //局部内部类
        class Inner{
            public void in(){
                System.out.println("in");
            }
        }
    }
}

4.匿名内部类

类Demo04

public class Demo04 {
    public static void main(String[] args) {
        //匿名内部类,没有名字初始化,不用将实例保存到变量中
        new Apple().eat();

        UserService userService = new UserService() {
            @Override
            public void hello() {
                System.out.println("hello");
            }
        };
    }
}

//一个java类文件中可以写多个类，但只能有一个public类
//与写在不同类文件中使用基本相同
class Apple{
    public void eat(){
        System.out.println("eat");
    }
}

interface UserService{
    void hello();
}