Day08

cherish9927

已于 2023-11-28 11:11:08 修改

阅读量99

点赞数

分类专栏： Java SE 文章标签： java 开发语言

于 2023-11-14 22:29:29 首次发布

本文链接：https://blog.csdn.net/qq_43069447/article/details/134402081

版权

Java SE 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

1. 接口(interface)

1.1 介绍

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要…则必须能…”的思想。继承是一个"是不是"的 is-a 关系，而接口实现则是 "能不能"的has-a 关系。

1.2 接口内部结构的说明

可以声明：

属性：必须使用public static final修饰（开发中可以省略）
方法：JDK8之前声明抽象方法修饰为public abstract（开发中可以省略），JDK8声明静态方法、默认方法，JDK9声明私有方法。

不可以声明：构造器

interface Flyable{
    int MIN_SPEED = 0;
    void fly();
}

1.3 接口的使用规则

1.3.1 类实现接口

接口不能创建对象，但是可以被类实现（implements ，类似于被继承）。类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用 implements 关键字。
接口的多实现（implements）：之前学过，在继承体系中，一个类只能继承一个父类。而对于接口而言，一个类是可以实现多个接口的，这叫做接口的多实现。并且，一个类能继承一个父类，同时实现多个接口。
注意：
• 如果接口的实现类是非抽象类，那么必须重写接口中所有抽象方法。
• 默认方法可以选择保留，也可以重写。
• 重写时，default 单词就不要再写了，它只用于在接口中表示默认方法，到类中就没有默认方法的概念。
• 接口中的静态方法不能被继承也不能被重写。

interface Flyable{
    int MIN_SPEED = 0;
    void fly();
}
interface Attackable{
    void attack();
}

class Plane implements Flyable,Attackable{

    @Override
    public void fly() {

    }

    @Override
    public void attack() {
        
    }
}

1.3.2 接口之间的继承

一个接口能继承另一个或者多个接口，接口的继承也使用 extends 关键字，子接口继承父接口的方法。

interface A{
    void method1();
}
interface B{
    void method2();
}
interface C extends A,B{
    void method3();
}

1.3.3 接口的多态性

实现类实现接口，类似于子类继承父类，因此，接口类型的变量与实现类的对象之间，也可以构成多态引用。通过接口类型的变量调用方法，最终执行的是new 的实现类对象实现的方法体。

1.3.4 区分抽象类和接口

共性：

都可以声明抽象方法。
都不能实例化。

不同

抽象类一定有构造器，接口没有构造器。
类和类之间是继承关系，类与接口之间是实现关系，接口和接口之间是多继承关系。

2. 内部类

2.1 介绍

将一个类 A 定义在另一个类 B 里面，里面的那个类 A 就称为内部类（InnerClass），类 B 则称为外部类（OuterClass）。

2.2 作用

具体来说，当一个事物 A 的内部，还有一个部分需要一个完整的结构 B 进行描述，而这个内部的完整的结构 B 又只为外部事物 A 提供服务，不在其他地方单独使用，那么整个内部的完整结构 B 最好使用内部类。
总的来说，遵循高内聚、低耦合的面向对象开发原则。

2.3 分类

内部类可以分为成员内部类和局部内部类。成员内部类又分为静态成员内部类和非静态成员内部类，局部内部类（声明在方法内、构造器内、代码块内的内部类）又分为非匿名局部内部类和匿名局部内部类。

2.4 成员内部类

2.4.1 介绍

从类的角度看：

内部类可以声明属性、方法、构造器、代码块、内部类等结构。
此内部类可以声明父类，可以实现接口。
可以使用final修饰。
可以使用abstract修饰。

从外部类的成员的角度看：

在内部可以调用外部类的结构。比如：属性、方法等。
除了使用public、缺省权限修饰之外，还可以使用private、protected修饰。
可以使用static修饰。

如果成员内部类中不使用外部类的非静态成员，那么通常将内部类声明为静态内部类，否则声明为非静态内部类。

2.4.2 创建成员内部类对象

实例化静态内部类：
外部类名.静态内部类名变量 = 外部类名.静态内部类名();
变量.非静态方法();
实例化非静态内部类：
外部类名变量 1 = new 外部类();
外部类名.非静态内部类名变量 2 = 变量 1.new 非静态内部类名();
变量 2.非静态方法();

3. 枚举类

3.1 介绍

枚举类型本质上也是一种类，只不过是这个类的对象是有限的、固定的几个，不能让用户随意创建。
若枚举只有一个对象, 则可以作为一种单例模式的实现方式。
枚举类的实现：

在 JDK5.0 之前，需要程序员自定义枚举类型。
在 JDK5.0 之后，Java 支持 enum 关键字来快速定义枚举类型。

开发中如果针对于某个类，其实例是确定个数，则推荐将此类声明为枚举类。

3.2 JDK5.0之前定义枚举类

私有化类的构造器，保证不能在类的外部创建其对象。
在类的内部创建枚举类的实例。声明为：public static final ，对外暴露这些常量对象。
对象如果有实例变量，应该声明为 private final（建议，不是必须），并在构造器中初始化。

class Season{
    //1.声明当前类的对象的实例变量
    private final String seasonName;
    //2.私有化类的构造器
    private Season(String seasonName){
        this.seasonName = seasonName;
    }
    //3.提供实例变量的get方法
    public String getSeasonName() {
        return seasonName;
    }

    //4.创建当前类的实例
    public static final Season SPRING = new Season("春天");
    public static final Season SUMMER = new Season("夏天");
    public static final Season AUTUMN = new Season("秋天");
    public static final Season WINTER = new Season("冬天");
}

3.3 JDK5.0之后使用enum关键字定义枚举类

public enum Week {
 MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY,SATURDAY,SUNDAY;
}

3.3.1 enum 方式定义的要求和特点

枚举类的常量对象列表必须在枚举类的首行，因为是常量，所以建议大写。
列出的实例系统会自动添加 public static final 修饰。
如果常量对象列表后面没有其他代码，那么“；”可以省略，否则不可以省略“；”。
编译器给枚举类默认提供的是 private 的无参构造，如果枚举类需要的是无参构造，就不需要声明，写常量对象列表时也不用加参数。
如果枚举类需要的是有参构造，需要手动定义，有参构造的 private 可以省略，调用有参构造的方法就是在常量对象名后面加(实参列表)就可以。
枚举类默认继承的是 java.lang.Enum 类，因此不能再继承其他的类型。
JDK5.0 之后 switch，提供支持枚举类型，case 后面可以写枚举常量名，无需添加枚举类作为限定。

3.4 Enum中的常用方法

String toString(): 默认返回的是常量名（对象名），可以继续手动重写该方法！
static 枚举类型[] values():返回枚举类型的对象数组。该方法可以很方便地遍历所有的枚举值，是一个静态方法。
static 枚举类型 valueOf(String name)：可以把一个字符串转为对应的枚举类对象。要求字符串必须是枚举类对象的“名字”。如不是，会有运行时异常：IllegalArgumentException。
String name():得到当前枚举常量的名称。建议优先使用 toString()。
int ordinal():返回当前枚举常量的次序号，默认从 0 开始。

3.5 实现接口的枚举类

和普通 Java 类一样，枚举类可以实现一个或多个接口。
若每个枚举值在调用实现的接口方法呈现相同的行为方式，则只要统一实现该方法即可。
若需要每个枚举值在调用实现的接口方法呈现出不同的行为方式，则可以让每个枚举值分别来实现该方法。

3.6 使用枚举类实现单例模式

//JDK5.0之前
class Bank1{
    private Bank1(){}
    public static final Bank1 instance = new Bank1();
}
//JDK5.0之后
enum Bank2{
    CCB;
}

package p117.test3;

public class ColorTest {
    public static void main(String[] args) {
        System.out.println(Color.GREEN);
    }
}

enum Color{
    RED(255,0,0,"红色"),
    ORANGE(255,128,0,"橘色"),
    YELLOW(255,255,0,"黄色"),
    GREEN(0,255,0,"绿色"),
    CYAN(0,255,255,"青色"),
    BLUE(0,0,255,"蓝色"),
    PUPPLE(128,0,255,"紫色");


    private final int red;
    private final int green;
    private final int blue;
    private final String description;

    Color(int red, int green, int blue, String description) {
        this.red = red;
        this.green = green;
        this.blue = blue;
        this.description = description;
    }

    public int getRed() {
        return red;
    }

    public int getGreen() {
        return green;
    }

    public int getBlue() {
        return blue;
    }

    public String getDescription() {
        return description;
    }

    @Override
    public String toString() {
        return "Color{" +
                "red=" + red +
                ", green=" + green +
                ", blue=" + blue +
                ", description='" + description + '\'' +
                '}';
    }
}

4.注解（Annotation）

4.1 介绍

注解（Annotation）是从 JDK5.0 开始引入，以“@注解名”在代码中存在。Annotation 可以像修饰符一样被使用，可用于修饰包、类、构造器、方法、成员变量、参数、局部变量的声明。还可以添加一些参数值，这些信息被保存在Annotation 的 “name=value” 对中。注解可以在类编译、运行时进行加载，体现不同的功能。

4.2 注解和注释

注解也可以看做是一种注释，通过使用 Annotation，程序员可以在不改变原有逻辑的情况下，在源文件中嵌入一些补充信息。但是，注解，不同于单行注释和多行注释。

对于单行注释和多行注释是给程序员看的。
而注解是可以被编译器或其他程序读取的。程序还可以根据注解的不同，做出相应的处理。

4.3 注解的重要性

在 JavaSE 中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在 JavaEE/Android 中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替 JavaEE 旧版中所遗留的繁冗代码和 XML 配置等。
未来的开发模式都是基于注解的，JPA 是基于注解的，Spring2.5 以上都是基于注解的，Hibernate3.x 以后也是基于注解的，Struts2 有一部分也是基于注解的了。注解是一种趋势，一定程度上可以说：框架 = 注解 + 反射 + 设计模式。

4.4 Java基础中的三个常用注解

4.4.1 @Override

用于检测被标记的方法为有效的重写方法，如果不是，则报编译错误！
只能标记在方法上。
它会被编译器程序读取。

4.4.2 @Deprecated

用于表示被标记的数据已经过时，不推荐使用。
可以用于修饰属性、方法、构造、类、包、局部变量、参数。
它会被编译器程序读取。

4.4.3 @SuppressWarnings

抑制编译警告。当我们不希望看到警告信息的时候，可以使用 SuppressWarnings 注解来抑制警告信息。
可以用于修饰类、属性、方法、构造、局部变量、参数
它会被编译器程序读取。
可以指定的警告类型有all，抑制所有警告；unchecked，抑制与未检查的作业相关的警告；unused，抑制与未用的程式码及停用的程式码相关的警告；deprecation，抑制与淘汰的相关警告；nls，抑制与非 nls 字串文字相关的警告；null，抑制与空值分析相关的警告；rawtypes，抑制与使用 raw 类型相关的警告；static-access，抑制与静态存取不正确相关的警告；static-method，抑制与可能宣告为 static 的方法相关的警告；super，抑制与置换方法相关但不含 super 呼叫的警告。

4.5 自定义注解的使用

一个完整的注解应该包含三个部分：（1）声明（2）使用（3）读取。

4.6 元注解

JDK1.5 在 java.lang.annotation 包定义了 4 个标准的 meta-annotation 类型，它们被用来提供对其它 annotation 类型作说明。
@Target：用于描述注解的使用范围。

可以通过枚举类型 ElementType 的 10 个常量对象来指定。
TYPE，METHOD，CONSTRUCTOR，PACKAGE…。

@Retention：用于描述注解的生命周期

可以通过枚举类型 RetentionPolicy 的 3 个常量对象来指定。
SOURCE（源代码）、CLASS（字节码）、RUNTIME（运行时），唯有 RUNTIME 阶段才能被反射读取到。

@Documented：表明这个注解应该被 javadoc 工具记录。
@Inherited：允许子类继承父类中的注解。

4.7 JUnit 单元测试

4.7.1 介绍

JUnit 是由 Erich Gamma 和 Kent Beck 编写的一个测试框架（regression testing framework），供 Java 开发人员编写单元测试之用。JUnit 测试是程序员测试，即所谓白盒测试，因为程序员知道被测试的软件如何（How）完成功能和完成什么样（What）的功能。要使用 JUnit，必须在项目的编译路径中引入 JUnit 的库，即相关的.class 文件组成的 jar 包。
JUnit4 版本，要求@Test 标记的方法必须满足如下要求：

所在的类必须是 public 的，非抽象的，包含唯一的无参构造器。
@Test 标记的方法本身必须是 public，非抽象的，非静态的，void 无返回值，()无参数的。

5. wrapper包装类

5.1 介绍

Java 针对八种基本数据类型定义了相应的引用类型：包装类（封装类）。有了类的特点，就可以调用类中的方法，Java 才是真正的面向对象。
在这里插入图片描述

5.2 包装类与基本数据类型间的转换

5.2.1 理由

一方面，在有些场景下，需要使用基本数据类型对应的包装类的对象。此时就需要将基本数据类型的变量转换为包装类的对象。比如，ArrayList的add(0bject obj);0bject类的equals(Object obj)。
对于包装类来讲，既然我们使用的是对象，那么对象是不能进行+ - * / 等运算的。为了能够进行这些运算，就需要将包装类的对象转换为基本数据类型的变量。

5.2.2 转换

基本数据类型转换为包装类：

使用包装类的构造器。
（建议）调用包装类的valueOf(xxx xx)。

Integer obj1 = new Integer(4);//使用构造函数
Float f = new Float(“4.56”);
Long l = new Long(“asdf”); //NumberFormatException
Integer obj2 = Integer.valueOf(4);//使用包装类中的 valueOf 方法

包装类转换为基本数据类型：

调用包装类的xxxValue()。

Integer obj = new Integer(4);
int num1 = obj.intValue();

注意：原来使用基本数据类型变量的位置，转换为包装类后，对于成员变量来说，其默认值发生变化。

5.2.3 自动装箱与拆箱

由于我们经常要做基本类型与包装类之间的转换，从 JDK5.0 开始，基本类型与包装类的装箱、拆箱动作可以自动完成。注意：只能与自己对应的类型之间才能实现自动装箱与拆箱。

5.3 基本数据类型、包装类与字符串间的转换

5.3.1 基本数据类型转为字符串

方式 1：调用字符串重载的 valueOf()方法。

int a = 10;
//String str = a;//错误的
String str = String.valueOf(a);

方式 2：更直接的方式。

int a = 10;
String str = a + "";

5.3.2 字符串转为基本数据类型

方式 1：除了 Character 类之外，其他所有包装类都具有 parseXxx 静态方法可以将字符串参数转换为对应的基本类型，例如：

public static int parseInt(String s)：将字符串参数转换为对应的 int 基本类型。
public static long parseLong(String s)：将字符串参数转换为对应的 long基本类型。
public static double parseDouble(String s)：将字符串参数转换为对应的double 基本类型。

方式 2：字符串转为包装类，然后可以自动拆箱为基本数据类型

public static Integer valueOf(String s)：将字符串参数转换为对应的Integer 包装类，然后可以自动拆箱为 int 基本类型。
public static Long valueOf(String s)：将字符串参数转换为对应的 Long包装类，然后可以自动拆箱为 long 基本类型。
public static Double valueOf(String s)：将字符串参数转换为对应的Double 包装类，然后可以自动拆箱为 double 基本类型。
注意:如果字符串参数的内容无法正确转换为对应的基本类型，则会抛出java.lang.NumberFormatException 异常。

方式 3：通过包装类的构造器实现

int a = Integer.parseInt(“整数的字符串”);
double d = Double.parseDouble(“小数的字符串”);
boolean b = Boolean.parseBoolean(“true 或 false”);
int a = Integer.valueOf(“整数的字符串”);
double d = Double.valueOf(“小数的字符串”);
boolean b = Boolean.valueOf(“true 或 false”);
int i = new Integer(“12”);

cherish9927

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Day08

将一个类 A 定义在另一个类 B 里面，里面的那个类 A 就称为内部类（InnerClass），类 B 则称为外部类（OuterClass）。从类的角度看：内部类可以声明属性、方法、构造器、代码块、内部类等结构。此内部类可以声明父类，可以实现接口。可以使用final修饰。可以使用abstract修饰。从外部类的成员的角度看：在内部可以调用外部类的结构。比如：属性、方法等。除了使用public、缺省权限修饰之外，还可以使用private、protected修饰。
复制链接

扫一扫