自学JAVA笔记07（基础篇）

抽象类

• abstract修饰抽象类，抽象方法
  • 抽象类的子类必须完成抽象类中的抽象方法，除非该子类也是抽象类
  • 抽象类只是做个约束，别人会帮我们实现
  • 抽象方法，只有方法头，没有方法体
  • 不能new这个抽象类，只能靠子类去实现它(约束)
  • 抽象方法必须再抽象类中，抽象类中可以写普通的方法

关于抽象类比较抽象，比较难用语言描述，需要实践去尝试

//抽象类
public abstract class Action {
    public void Action(){
        System.out.println("抽象类的构造器");
    }
    public abstract void doSomething();
}

抽象类的子类

public class Action1 extends Action{

    public void Action1(){
        System.out.println("A1的构造器");
    }
    @Override
    public void doSomething(){
        System.out.println("Hello");
    };
}

主程序

public static void main(String[] args) {
    Action1 a1 = new Action1();
    a1.doSomething();
}

• 如果你要new抽象类的话，IDEA会提示你无法实例化。

  

• 从运行结果来看，没有使用到构造器

• 抽象类，就相当于我们玩游戏创建角色的时候需要捏脸，角色它是一个抽象类，做了许多人物细节（眼睛、鼻子、嘴巴等）上的约束，用户创建角色就相当于在创建抽象类的子类，它在完成这些细节的具体方法（眼睛的形状大小，嘴巴的形状大小等）。

接口

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

• 接口的本质是契约，就像各个国家的法律一样。制定好后对应国家的人民都要遵守。

• 接口不能实例化

• 一个类通过implements可以实现多个接口

• 在类实现接口的时候必须将接口中的方法全部重写

接口1

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

接口2

public interface TimeService {
    void time();
}

实现接口的类

//类实现接口 implements 接口
//实现接口的类，必须重写接口中的所有方法
//接口可以实现多继承
public class UserServiceImpl implements UserService,TimeService {
    public void time() {
    }
    public void add(String name) {

    }
    public void delete(String name) {

    }
    public void updata(String name) {

    }
    public void query(String name) {

    }
}

内部类

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

类

public class Outer {
    private int id=7;
    public void out(){
        System.out.println("外部类的方法");
    }
    //成员内部类
    public class Inner{
        public void in(){
            System.out.println("内部类的方法");
        }
        //可以获得外部类的私有属性
        public void getID(){
            System.out.println(id);
        }
    }
    //静态内部类，无法调用外部类的属性（static的特性）
    public static class Inner2{
        public void in(){
            System.out.println("静态内部类的方法");
        }
    }
    //局部内部类，在方法中定义类
    public void method(){
        class Inner{
            public void in(){

            }
        }
    }
}

主程序

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        outer.out();
        inner.in();
        inner.getID();
        //匿名内部类，没有对象名
        new Outer().out();
    }
}

运行结果