抽象类、接口及内部类的基本概念

Java基础（七）

抽象类、接口、内部类

抽象类

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

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

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

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

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

抽象类存在的意义：将复杂公共的属性抽象出来，提高开发的效率。

接口

普通类：只有具体的实现

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

接口：只有规范！自己无法写方法（专业的约束）

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是。。。则必须能。。。”的思想。

接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。

OO的精髓，是对对象的抽象，最能体现这一点的就是接口。

接口的作用：

• 定义一些方法，让不同的人去实现
• 所有方法都默认由public abstract 修饰
• 所有的常量都有public static final修饰（但是一般不在接口中定义常量）
• 接口不能被实例化，接口中没有构造方法
• implements可以实现多个接口
• implements接口之后，必须要重写接口中的所有方法。

举例：

UserService接口：

package David.Study.Oop.Demo08;

public interface UserService {

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

TimeService接口：

package David.Study.Oop.Demo08;

public interface TimeService {
    void timer();
}

UserServiceImpl类

package David.Study.Oop.Demo08;

//抽象类：extends
//类，可以实现接口：implements 接口
//实现了接口的类，就需要重写接口中的方法
//利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{
    @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类来说就是外部类了。

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

成员内部类，静态内部类，局部内部类举例：

package David.Study.Oop.Demo09;

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 static class Sinner{

    }

    public void method(){
        //局部内部类
        class InInner{
            public void in(){

            }
        }
    }
}

调用程序：

package David.Study.Oop;

import David.Study.Oop.Demo09.Outer;

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

        //对于外部类用new
        Outer outer = new Outer();

        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        //通过内部类可以获取外部类的属性
        inner.getID();
    }
}

匿名内部类举例：

package David.Study.Oop.Demo09;

public class Test {
    public static void main(String[] args) {
        new Apple().eat();

        UserService userService = new UserService(){
            @Override
            public void hello() {
                System.out.println("匿名内部类");
            }
        };
        userService.hello();//输出：匿名内部类
    }
}

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

interface UserService{
    void hello();
}