10.枚举_Record_密封类_debug_API文档_Object类_lombok_Junit

第一章.枚举

1.枚举介绍

java 复制代码

1.引用类型: 类 数组 接口 枚举 注解 Record
2.定义:
  public enum 枚举类名{
      
  }

3.定义枚举变量:
  a.定义格式:直接写变量名即可(默认是public static final修饰的,但是不要写出来)
            枚举变量之间用,隔开,如果是最后一个枚举变量就用;结束
  b.注意:每一个枚举变量都是这个枚举类的对象,其实我们写的枚举变量名都是对象名
      
4.问题:枚举变量的类型是什么类型  -> 当前枚举类的类型
    
5.枚举类的其他成员:
  a.构造方法:构造方法在枚举类中都是private的
      
6.枚举的使用场景:表示一种事物的状态

java 复制代码

public enum State {
    //State WEIFUKUAN = new State()
    //State WEIFUKUAN = new State("未付款")
    WEIFUKUAN("未付款"),
    //State YIFUKUAN = new State()
    //State YIFUKUAN = new State("已付款")
    YIFUKUAN("已付款"),
    //State WEIFAHUO = new State()
    //State WEIFAHUO = new State("未发货")
    WEIFAHUO("未发货"),
    //State YIFAHUO = new State()
    //State YIFAHUO = new State("已发货")
    YIFAHUO("已发货"),
    //State YISHOUHUO = new State()
    //State YISHOUHUO = new State("已收货")
    YISHOUHUO("已收货");


    //定义成员变量
    private String name;
    /**
     * 空参构造
     */
    private State(){

    }

    /**
     * 带参构造
     * @param name
     */
    private State(String name){
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

java 复制代码

public class Test01 {
    public static void main(String[] args) {
        State weifukuan = State.WEIFUKUAN;
        System.out.println(weifukuan);

        State yifahuo = State.YIFAHUO;
        System.out.println(yifahuo);
        System.out.println(yifahuo.getName());

    }
}

2.枚举的方法_Enum

方法名	说明
String toString()	返回枚举变量的名字,返回的是字符串
values()	返回所有的枚举变量
valueOf(String str)	将一个字符串转成枚举变量

java 复制代码

public enum State {
    //State WEIFUKUAN = new State()
    //State WEIFUKUAN = new State("未付款")
    WEIFUKUAN("未付款"),
    //State YIFUKUAN = new State()
    //State YIFUKUAN = new State("已付款")
    YIFUKUAN("已付款"),
    //State WEIFAHUO = new State()
    //State WEIFAHUO = new State("未发货")
    WEIFAHUO("未发货"),
    //State YIFAHUO = new State()
    //State YIFAHUO = new State("已发货")
    YIFAHUO("已发货"),
    //State YISHOUHUO = new State()
    //State YISHOUHUO = new State("已收货")
    YISHOUHUO("已收货");


    //定义成员变量
    private String name;
    /**
     * 空参构造
     */
    private State(){

    }

    /**
     * 带参构造
     * @param name
     */
    private State(String name){
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

java 复制代码

public class Test02 {
    public static void main(String[] args) {
        //String toString()返回枚举常量的名字,返回的是字符串
        State yifahuo = State.YIFAHUO;
        System.out.println(yifahuo);//是State类型
        System.out.println(yifahuo.toString());//是String类型

        System.out.println("====================");
        //values()返回所有的枚举变量
        State[] values = State.values();
        for (int i = 0; i < values.length; i++) {
            System.out.println(values[i]);
        }

        System.out.println("====================");
        //valueOf(String str)将一个字符串转成枚举变量
        State YIFAHUO = State.valueOf("YIFAHUO");
        System.out.println(YIFAHUO);
    }
}

第二章.Record和密封类

1.Record类

Record类在JDK14、15预览特性，在JDK16中转正。

record是一种全新的类型，它本质上是一个 final类，同时所有的属性都是 final修饰，它会自动编译出get(不是getxxx方法,而是属性名())、hashCode 、比较所有属性值的equals、toString 等方法，减少了代码编写量。使用 Record 可以更方便的创建一个常量类。

1.注意:

Record只会有一个全参构造
重写的equals方法比较所有属性值
可以在Record声明的类中定义静态字段、静态方法或实例方法(非静态成员方法)。
不能在Record声明的类中定义实例字段(非静态成员变量)；
类不能声明为abstract；
不能显式的声明父类，默认父类是java.lang.Record类

因为Record类是一个 final类，所以也没有子类等。

java 复制代码

public record Person(String name, int age) {

}

java 复制代码

public class Test {
    public static void main(String[] args) {
        Person person1 = new Person("zhangsan", 18);
        System.out.println(person1.name()+"..."+person1.age());
    }
}

2.密封类

其实很多语言中都有密封类的概念，在Java语言中,也早就有密封类的思想，就是final修饰的类，该类不允许被继承。而从JDK15开始,针对密封类进行了升级。

Java 15通过密封的类和接口来增强Java编程语言，这是新引入的预览功能并在Java 16中进行了二次预览，并在Java17最终确定下来。这个预览功能用于限制超类的使用，密封的类和接口限制其他可能继承或实现它们的其他类或接口。

java 复制代码

【修饰符】 sealed class 密封类 【extends 父类】【implements 父接口】 permits 子类{
    
}
【修饰符】 sealed interface 接口 【extends 父接口们】 permits 实现类{
    
}

密封类用 sealed 修饰符来描述，
使用 permits 关键字来指定可以继承或实现该类的类型有哪些
一个类继承密封类或实现密封接口，该类必须是sealed、non-sealed、final修饰的。
sealed修饰的类或接口必须有子类或实现类

java 复制代码

public sealed class Animal permits Dog,Cat{
}

public non-sealed class Dog extends Animal{
}

public non-sealed class Cat extends Animal{
}

java 复制代码

package com.atguigu.sealed;

import java.io.Serializable;

public class TestSealedInterface {
    
}
sealed interface Flyable /*extends Serializable*/ permits Bird {
    
}
non-sealed class Bird implements Flyable{
   
}

第三章.debug的使用

java 复制代码

1.概述:是一个代码的调试工具
2.作用:
  让代码一行一行的执行,不是一下子就全部执行完毕
  看到变量值的变化
3.怎么用:
  a.打断点(在我们想要开始debug的代码左边点击一下,出现小红点)
  b.运行(以debug默认运行代码)

第四章.Java其他操作_API文档

1.API文档

java 复制代码

1.API概述(Application Programming Interface -> 应用程序接口):其实就是类以及类中的属性,构造,方法等,这些都叫API
2.API文档:针对api造出的一个文档,供我们去查询使用

第五章.Object类

java 复制代码

1.概述:是所有类的父类,所有类都会直接或者间接继承Object
       public class Zi extends Fu{}  -> Zi类的亲爹是Fu
       public class Fu{}   -> Fu类的亲爹就是Object

1.toString方法

java 复制代码

1.Object中的toString方法:
  public String toString() {
      return getClass().getName() + "@" + Integer.toHexString(hashCode());
  }

2.结论:
  a.没有重写Object中的toString方法,直接输出对象名会默认调用Object中的toString方法,输出地址值
  b.如果重写了Object中的toString方法,直接输出对象名会默认调用重写的toString方法,输出对象的内容

java 复制代码

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

/*    @Override
    public String toString() {
        return name+","+age;
    }*/

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

java 复制代码

public class Test01 {
    public static void main(String[] args) {
        Person p1 = new Person("张三", 18);
        System.out.println(p1);
        System.out.println(p1.toString());

        System.out.println("==========================");
        ArrayList<String> list = new ArrayList<>();
        list.add("hello");
        list.add("world");
        System.out.println(list);//[hello, world]
    }
}

小结:直接输出对象名,不想输出地址值,想输出对象的内容,就重写toString方法

2.equals方法

java 复制代码

1.Object中的equals方法:判断来个对象是否相等
  public boolean equals(Object obj){
      return (this == obj);
  }

  ==针对于基本类型:比较的是值
  ==针对于引用类型:比较的是地址值

java 复制代码

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

/*    @Override
    public String toString() {
        return name+","+age;
    }*/

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    /**
     * 问题1:obj.name和obj.age为啥报错?
     *      name和age是子类中特有的,多态前提下,不能直接调用子类特有的
     * 解决问题1:向下转型
     *
     * 问题2:如果传递传递过来的不是Person类型的对象,强转成Person会报
     *      类型转换异常
     * 解决问题2:判断obj是否是Person类型
     *
     * 问题3:如果传递的参数是null,容易报空指针异常
     * 解决问题3:判断obj是否为null
     *
     * 问题4:如果传递的参数是自己呢?其实就不需要判断类型了,不需要强转了
     *      直接返回true了
     *
     * @return
     */
/*    @Override
    public boolean equals(Object obj) {
        if (this == obj){
            return true;
        }

        if (obj == null){
            return false;
        }

        if (obj instanceof Person){
            Person p2 = (Person)obj;
            return this.name.equals(p2.name)&&this.age==p2.age;
        }

        return false;
    }*/

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person p1 = (Person) o;
        return age == p1.age && Objects.equals(name, p1.name);
    }
    
}

java 复制代码

public class Test02 {
    public static void main(String[] args) {
        Person p1 = new Person("张三", 18);
        Person p2 = new Person("张三", 18);
        System.out.println(p1 == p2);//false
        System.out.println(p1.equals(p2));//true

        //ArrayList<String> list = new ArrayList<>();
        //System.out.println(p1.equals(p1));//false

        System.out.println("==============================");
        String s1 = new String("abc");
        String s2 = new String("abc");
        System.out.println(s1==s2);//false
        System.out.println(s1.equals(s2));//true
    }
}

小结:调用equals方法的之后不想比较对象的地址值,而是想比较对象的内容,就重写equals方法

第六章.lombok

java 复制代码

1.概述:是一个第三方工具
2.作用:主要是简化javabean开发的

xml 复制代码

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.30</version>
</dependency>

java 复制代码

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Person {
    private String name;
    private int age;
}

java 复制代码

public class Test01 {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("张三");
        person.setAge(18);
        System.out.println(person.getName()+"..."+person.getAge());
        System.out.println("===========================");
        Person person1 = new Person("李四", 20);
        System.out.println(person1.getName()+"..."+person1.getAge());
    }
}

1.lombok介绍

Lombok通过增加一些"处理程序"，可以让javabean变得简洁、快速。

Lombok能以注解形式来简化java代码，提高开发效率。开发中经常需要写的javabean，都需要花时间去添加相应的getter/setter，也许还要去写构造器、equals等方法，而且需要维护。

Lombok能通过注解的方式，在编译时自动为属性生成构造器、getter/setter、equals、hashcode、toString方法。出现的神奇就是在源码中没有getter和setter方法，但是在编译生成的字节码文件中有getter和setter方法。这样就省去了手动重建这些代码的麻烦，使代码看起来更简洁些。

2.lombok常用注解

@Getter和@Setter

作用：生成成员变量的get和set方法。
写在成员变量上，指对当前成员变量有效。
写在类上，对所有成员变量有效。
注意：静态成员变量无效。

@ToString

作用：生成toString()方法。
注解只能写在类上。

@NoArgsConstructor和@AllArgsConstructor

@NoArgsConstructor：无参数构造方法。
@AllArgsConstructor：满参数构造方法。
注解只能写在类上。

@EqualsAndHashCode

作用：生成hashCode()和equals()方法。
注解只能写在类上。

@Data

作用：生成get/set，toString，hashCode，equals，无参构造方法
注解只能写在类上。

第八章.单元测试

1.Junit介绍

java 复制代码

1.概述:是一个单元测试框架,可以代替main方法来测试代码是否能跑通

xml 复制代码

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
    <scope>compile</scope>
</dependency>

2.Junit的基本使用(重点)

java 复制代码

1.Junit中的常用注解
  a.@Test:单独执行一个方法

java 复制代码

public class Demo01Junit {
    @Test
    public void test01(){
        System.out.println("test01");
    }

    @Test
    public void test02(){
        System.out.println("test02");
    }
}

3.Junit的注意事项

java 复制代码

1.@Test修饰的方法不能有参数
2.@Test修饰的方法不能有返回值
3.@Test修饰的方法不能是静态的

4.Junit相关注解

java 复制代码

1.@Before:在@Test之前执行,有多少个@Test一起执行@Before修饰的方法就执行几次 -> 可以用于初始化数据
2.@After:在@Test之后执行,有多少个@Test一起执行@After修饰的方法就执行几次  -> 可以用于释放资源

java 复制代码

public class Demo01Junit {
    @Test
    public void test01(){
        System.out.println("test01");
    }

    @Test
    public void test02(){
        System.out.println("test02");
    }

    @Before
    public void before(){
        System.out.println("before");
    }

    @After
    public void after(){
        System.out.println("after");
    }
}

5.@Test以后怎么使用

将来我们会单独定义一个类(测试类),这个类中所写的方法,都是用于测试其他开发好的功能的

java 复制代码

public interface CategoryInterface {
    /**
     * 添加商品分类
     */
    boolean addCategory(String...arr);

    /**
     * 查询所有商品分类
     */
    ArrayList<String> queryAllCategory();
}

java 复制代码

public class CategoryImpl implements CategoryInterface{
    @Override
    public boolean addCategory(String... arr) {
        //创建一个集合
        ArrayList<String> list = new ArrayList<>();
        for (String element : arr) {
            //将数组中的元素放到集合中
            list.add(element);
        }

        if (list.size()>0){
            //返回true代表有数据
            return true;
        }else{
            //返回false代表没有数据
            return false;
        }
    }

    /**
     * 查询所有商品分类
     * @return
     */
    @Override
    public ArrayList<String> queryAllCategory() {
        ArrayList<String> list = new ArrayList<>();
        list.add("手机");
        list.add("电脑");
        list.add("箱包");
        list.add("水果");
        list.add("烟酒");
        return list;
    }
}

java 复制代码

public class CategoryTest {
    @Test
    public void addCategory() {
        CategoryImpl category = new CategoryImpl();
        boolean b = category.addCategory("手机", "箱包", "水果", "烟酒");
        System.out.println(b);
    }

    @Test
    public void queryAllCategory(){
        CategoryImpl category = new CategoryImpl();
        ArrayList<String> list = category.queryAllCategory();
        System.out.println(list);
    }
}

小技巧:

快速跳到实现类中 -> 将光标定位到定义接口这一行的位置 -> ctrl+alt+b