java基础---抽象类、接口、内部类

抽象类

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

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

抽象类：可以使用new关键字来创建对象，它是用来让子类继承的。

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

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

抽象类及抽象方法：
代码：

package oop.Abstract;

// abstract   抽象类
public abstract class Action {

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

子类继承抽象方法：
代码：

package oop.Abstract;

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

    }
}

1、不能new这个抽象类，只能靠子类去实现它。也是一种约束
2、抽象类中可以写普通的方法。
3、抽象方法必须在抽象类中。

思考：抽象类中有构造器吗？抽象类存在的意义是什么？

1、抽象类可以有构造方法，只是不能直接创建抽象类的实例对象而已。在继承了抽象类的子类中通过super()或super(参数列表)调用抽象类中的构造方法。
2、意义：对代码的维护和重用

接口

普通类：只有具体的实现。
抽象类：具体实现和规范（抽象方法）都有。
接口：只有规范。自己无法写方法，专业的约束，约束和实现分离：面向接口编程。

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

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

定义一个userService接口：
代码：

package oop.Intreface;

// interface 定义接口的关键字：接口都需要有实现类。
public interface UserService {

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

定义一个timeService接口：
代码：

package oop.Intreface;

public interface TimeService {

    void timer();
}

定义一个userService接口的实现类，实现了userService接口与timeService接口：
代码：

package oop.Intreface;


// 抽象类：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() {

    }
}

接口的作用：
  1、是一个约束。
  2、定义一些方法，让不同的人实现。
  3、接口中的方法默认是public abstract
  4、接口中的常量默认是public static final
  5、接口不能被实例化，因为接口中没有构造方法。
  6、就通过implements关键字可以实现多个接口。
  7、实现后，必须要重写接口中的方法。

内部类

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

内部类分类：
  1、成员内部类
  2、静态内部类
  3、局部内部类
  4、匿名内部类

成员内部类

先来看一段代码感受一下
代码：
定义一个内部类

package oop.NBN;

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

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

定义一个Application类来对外部类和内部类进行实例化：

package oop.NBN;

public class Application {

    public static void main(String[] args) {

        // 实例化外部类
        Outer outer = new Outer();

        // 通过这个外部类来实例化这个内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
    }
    
}

内部类能够获得外部类的私有属性和方法
内部类代码：

package oop.NBN;

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

Application类代码：

package oop.NBN;

public class Application {

    public static void main(String[] args) {

        // 实例化外部类
        Outer outer = new Outer();

        // 通过这个外部类来实例化这个内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getId();
    }

}

结果：

静态内部类

就是在内部类上加一个static关键字

package oop.NBN;

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

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

局部内部类

代码：

package oop.NBN;

public class JuBu {

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

        }
    }
}

匿名内部类

代码：

package oop.NBN;

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

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

interface userService{
    void run();
}

在此说明一下：本人不是托，我的这些总结都是根据哔哩哔哩的up主：遇见狂神说，我是看他的视频学习的，真心推荐这位up主，有兴趣的小伙伴可以去看看！！！