Java基础：抽象类、接口、内部类

抽象类

• 抽象类，类名中有abstract关键字
• 一种约束，让他人实现
• abstract抽象方法，只有方法名字，没有方法的实现
• 抽象类的所有方法，继承了它的子类，必须实现它的方法，除非子类也是抽象类

//abstract 抽象类：类，单继承（接口可以多继承）
public abstract class Action {

    //约束，让其他人实现
    //abstract抽象方法，只有方法名字，没有方法的实现
    public abstract void doSth();//没有大括号
}

//抽象类的所有方法，继承了它的子类，必须实现它的方法，除非子类也是抽象类
public class A extends Action{
    @Override
    public void doSth() {

    }
}

特点：

• 不能new抽象类，只能靠子类实现（约束）
• 抽象类中可以写普通方法
• 抽象方法必须在抽象类中
• 抽象的抽象：约束

抽象类中的构造器：

• 抽象类中存在默认构造器

抽象类存在的意义：防止重复代码，提高开发效率

接口

• 普通类：只有具体实现

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

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

• 接口是规范，定义的是一组规则，规定该物必须有该功能

• 接口的本质是契约，制定好后必须遵守

• 面向对象的精髓是对对象的抽象，最能体现这点的是接口。

• 接口的定义：

  • 接口声明的关键词是interface，接口需要有实现类
  • 接口中的所有定义都是抽象的，默认具有public abstract
  • 接口中只有方法的定义
  • 接口可以定义常量，默认public static final修饰，但不建议使用。

//interface 接口,接口需要有实现类
public interface UserService {

    //接口中只能定义常量：自动修饰public static final
    int A = 33;//一般不使用接口定义

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

• 实现类：
  • 实现类：可以实现接口，implements接口
  • 实现接口中的类，需要重写接口中的方法
  • 可以利用接口实现多继承(实现多个接口)
  • 快捷键：ctrl + i 重写方法

//实现类 可以实现接口，implements接口
//实现接口中的类，需要重写接口中的方法
//可以利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{
    //ctrl + i：重写
    @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() {}

• 接口的总结：
  • 约束：只能靠子类实现
  • 定义方法，让不同人实现
  • 接口中的定义是抽象的public abstract
  • 接口中定义常量public static final
  • 接口不能被实例化，接口中没有构造方法
  • implement可以实现多个接口
  • 接口的使用的要重写方法

内部类

• 内部类可以调用外部类的方法和私有属性
• 内部类通过外部类实例化

public class Outer {
    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);
        }
    }
}

public class Application {
    public static void main(String[] args) {
        //实例化
        Outer outer = new Outer();
        //通过外部类实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getID();

• 静态内部类

内部类是静态时，无法获取非静态的外部类的信息。

public class Outer {
    private int id;
    public void out(){
        System.out.println("外部类");
    }
    public static class Inner{
        public void in(){
            System.out.println("内部类");
        }
        public void getID(){
            //静态的内部类首先加载了，无法调用非静态的属性和方法
            //System.out.println(id)
        }
    }
}

• 一个Java类中可以有多个class类，只能有一个public class

仅被视作一个文件下有两个类，并且可以在类中使用mian方法

public class Outer {}
class A{}

• 局部内部类

方法里可以创建类

public class Test {
    public static void main(String[] args) {
        //没有名字初始化，不用将实例保存到变量中
        new Apply().eat();
    }
}

class Apply{
    public void eat(){
        System.out.println("1");
    }
}

• 匿名类

public class Test {
    public static void main(String[] args) {

        //没有名字，匿名类
        new UserService(){
            @Override
            public void hello() {  
            }
        };
    }
}
interface UserService{
    void hello();
}