【JAVA基础学习笔记10】-优快云博客

本文详细介绍了Java中的抽象类、接口以及内部类的概念和使用。抽象类作为基类，提供部分或全部抽象方法，不能实例化，用于被子类继承。接口作为规范，只包含抽象方法和常量，支持多继承，实现接口的类必须实现其所有方法。内部类包括成员内部类、静态内部类和局部内部类，用于增加代码封装性和复用性。匿名内部类则是一种简化创建新类的方式，常用于快速实现接口或父类的简单功能。

抽象类

abstract关键字修饰的类时抽象类，修饰的方法是抽象方法
抽象类中可以没有抽象方法，但抽象方法所在的类一定是抽象类
抽象类不能使用new创建对象，它是用来让子类继承的
抽象方法，只有方法的声明，没有方法的实现，它是让子类来实现的

//abstract 抽象类
public abstract class A {
    //是一个约束，抽象方法只有名字，没有实现方法
    public abstract void play();
    public void eat(){
        System.out.println("A-eat");
    }

    /*
    1. 不能new这个抽象类。只能靠子类去实现它
    2. 抽象类可以写普通方法，且不需要在子类中重写，可以被继承
    3. 抽象方法必须在抽象类中
    **抽象类中也存在构造器，它存在的意义为了提高开发效率
     */
}

//继承抽象类，必须要重写它的抽象方法，否则会报错；除非子类也是抽象类
public  class B extends A{
    @Override
    public void play() {
        System.out.println("palying");
    }
}

public class Application {
    public static void main(String[] args) {
        B b = new B();
        b.play(); //    palying  重写后可以调用
        b.eat();  // A-eat    可以直接继承
    }
}

接口

接口的本质是规范，且只有规范
可以实现多继承

接口是一个约束，使用interface关键字定义接口
接口可以定义一些方法，让不同的人实现
接口中的方法都是public abstract类型
接口中的常量都是public abstract final类型
接口不能被实例化，因为接口中没有构造方法
使用implement实现多借口
使用接口必须要重写接口中的方法

//接口1
//interface 接口定义的关键字，接口都需要有实现类
public interface UserService {
    //接口中的所有定义都是抽象的 public abstract
    void play();
    void eat();
}
//接口2
public interface Operation {
    void learn();
}
//使用类实现接口
//类使用implements实现接口中的方法，接口与抽象类相同，都必须重写其中的抽象方法
//接口可以实现多继承
public class UserServiceImp implements UserService,Operation{
    @Override
    public void play() {

    }

    @Override
    public void eat() {

    }

    @Override
    public void learn() {

    }
}

内部类

在一个类的内部再定义一个类

成员内部类

public class Demo01 {
    private int age=10;
    public void out(){
        System.out.println("this is outer");
    }
    //定义内部类
    public class Inner{
        public void in(){
            System.out.println("this is inner");
        }
        //可以通过内部类获得外部类中的私有属性
        public void gerAge(){
            System.out.println(age);
        }
    }
}

静态内部类

public class Demo01 {
    private int age=10;
    public void out(){
        System.out.println("this is outer");
    }
    //定义静态内部类
    public static  class Inner{
        public void in(){
            System.out.println("this is inner");
        }
        //可以通过内部类获得外部类中的私有属性
        public void gerAge(){
            System.out.println(age);
        }
    }
}

局部内部类
public class Demo01 {
private int age=10;
public void out(){
System.out.println(“this is outer”);
}
public void local(){
class Inner{
public void in(){
```
     }
 }
```
}

}

匿名内部类

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