JavaSE复习笔记（接口）

最新推荐文章于 2024-06-20 20:20:21 发布

Ren大白

最新推荐文章于 2024-06-20 20:20:21 发布

阅读量122

点赞数

分类专栏： JavaSE篇文章标签： java 开发语言

本文链接：https://blog.csdn.net/rbx508780/article/details/126841616

版权

JavaSE篇专栏收录该内容

15 篇文章 1 订阅

订阅专栏

一、抽象类

抽象类：有abstract关键字修饰的类

抽象类的定义格式：

【其他修饰符】  abstract class 类名{
    
}
//抽象类
public abstract class Aniaml{
    //抽象方法：有关键字abstract修饰的方法，没有方法体
    public abstract void eat();
}

抽象类的特点（对比具体的类）
- 抽象类有构造器，但是不能创建对象
- 抽象类可以有抽象方法，也可以没有，也可以有普通方法
- 有抽象方法的类必须是抽象类
- 抽象类的子类必须重写父类的所有抽象方法，除非子类也是抽象类

修饰符一起使用的问题

	外部类	成员变量	代码块	构造器	方法	局部变量	内部类（后面讲）
public	√	√	×	√	√	×	√
protected	×	√	×	√	√	×	√
缺省	√	√	×	√	√	×	√
private	×	√	×	√	√	×	√
static	×	√	√	×	√	×	√
final	√	√	×	×	√	√	√
abstract	√	×	×	×	√	×	√
native	×	×	×	×	√	×	×

不能和abstract一起使用的修饰符？

（1）abstract和final不能一起修饰方法和类

（2）abstract和static不能一起修饰方法

（3）abstract和native不能一起修饰方法

（4）abstract和private不能一起修饰方法

static和final一起使用：

（1）修饰方法：可以，因为都不能被重写

（2）修饰成员变量：可以，表示静态常量

（3）修饰局部变量：不可以，static不能修饰局部变量

（4）修饰代码块：不可以，final不能修改代码块

（5）修饰内部类：可以一起修饰成员内部类，不能一起修饰局部内部类

二、接口

接口：接口是一种规范。接口的意义主要是解耦合。

接口的定义格式：

使用关键字interface定义接口，类似定义Java类

【修饰符】 interface 接口名{
    //接口的成员:
    //JDK8之前：
    //1.静态常量
    //2.抽象方法
    //JDK8之后：
    //3.静态方法
    //4.默认方法
    //JDK9之后：
    //5.私有方法
}

public interface Jumpable{
    int x = 10;//静态常量，默认自带修饰符public static final
    void jump();//抽象方法，默认自带修饰符public abstract
    static void testStatic(){//静态方法
        
    }
    default void testDefault(){//默认方法
        
    }
    
    private void testPrivate(){//私有方法
        
    }
}

接口的实现：

通过类来实现接口，格式：

【修饰符】 class 实现类  implements 接口{
    // 重写接口中抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写
    // 重写接口中默认方法【可选】
}

【修饰符】 class 实现类 extends 父类 implements 接口{
    // 重写接口中抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写
    // 重写接口中默认方法【可选】
}

//Cat类继承Animal类，同时实现Jumpable接口
public class Cat extends Animal implements Jumpable{
    //重写父类的抽象方法
    @Override
    public void eat(){}
    //重写接口的抽象方法
    public void jump(){}
    //可以重写或不重写接口的默认方法
}

接口的成员访问

访问接口的抽象方法和默认方法，必须通过创建实现类对象来访问
访问接口的静态常量，通常使用接口名来访问

访问接口的静态方法，必须通过接口名来访问

//创建接口的实现类对象
Cat cat = new Cat();
//访问重写后的抽象方法
cat.eat();
//访问默认方法
cat.testDefault();
//访问静态常量
System.out.println(Jumpable.x);
//访问静态方法
Jumpable.testStatic();

接口的多态引用形式

接口类型的变量执行其实现类对象

Jumpable j = new Cat();
j.jump();
j.eat();//编译失败，因为Jumpable中没有eat方法
Cat c = (Cat)j;//j的运行时类型属于Cat类型，可以强转
c.eat();
Animal a = (Animal)j;//j的运行时类型属于Animal类型，可以强转
a.eat();

接口的多实现与多继承
- 类与类之间的关系，一个类可以继承自另一个类，Java类只支持单继承。
- 类与接口的关系，一个类可以同时实现多个接口
- 接口与接口的关系，一个接口可以同时继承自多个接口
接口的特点：（对比抽象类）
- 接口没有构造器，也不能创建对象
- 接口成员只能是：1.静态常量，2.抽象方法，3.静态方法，4.默认方法，5.私有方法
- 接口的实现类必须重写接口的所有抽象方法，除非实现类也是抽象类
- 接口可以继承接口，关键字是extends，而且支持多继承。
- 接口的默认方法可以选择重写或不重写。如果有冲突问题，另行处理。子类重写父接口的默认方法，要去掉default，子接口重写父接口的默认方法，不要去掉default。
- 接口的静态方法不能被继承，也不能被重写。接口的静态方法只能通过“接口名.静态方法名”进行调用。
Java经典接口
- java.lang.Comparable接口：一个类实现类此接口，这个类的对象就可以比通过重写compareTo方法比较对象的大小，自然排序。
- java.util.Comparator接口：通过创建此接口的实现类来对某种类型的对象进行比较大小，定制排序。
- java.lang.Clonealbe接口：一个类实现此接口，那么这个类的对象就可以被Object类的clone方法进行克隆。

三、内部类（理解）

内部类：定义在一个类的内部的类，称为内部类
内部类分类：
- 静态内部类：有static修饰
  
  静态内部类不能直接访问外部类的非静态成员，可以使用4种权限修饰符
- 非静态内部类：没有static修饰
  
  可以直接访问外部类的所有成员，不能定义静态成员，但是可以定义静态常量，可以使用4种权限修饰符
- 匿名内部类：没有名字的内部类
  
  创建匿名内部类对象的格式：
```
new 父类或接口(){
    //子类或实现类的成员
}
Danceable d = new Danceable(){
    @Override
    public void dance(){}
};
```

四、单例模式

设计模式：根据特定的需求总结的一套开发经验

单例模式：内存中只能出现某个类的一个实例。

饿汉式

public class Singleton{
    private static final Singleton instance = new Singleton();
    private Singleton(){}
    public static Singleton getInstance(){
        return instance;
    }
}

懒汉式

有线程安全问题。

public class Singleton{
    private static final Singleton instance = null;
    private Singleton(){}
    public static Singleton getInstance(){
        if(instance == null)
            instance = new Singleton();
        return instance;
    }
}

六、注解

注解：一种给程序看的标记，注解本身没有意义，需要编写相应的程序来识别注解并做出处理。
三个基本注解
- @Override 验证方法是否是重写的
- @Deprecated 表示过时的不推荐使用的
- @SuppressWarning("all") 抑制警告
自定义注解
```
public @interface MyAnno{
    
}
```