Javase面向对象8：设计模式、枚举、注解、单元测试、包装类

疯丰

已于 2022-05-12 07:52:24 修改

阅读量110

点赞数 1

分类专栏：大数据之javase基础文章标签： java 开发语言

于 2022-05-07 13:03:31 首次发布

本文链接：https://blog.csdn.net/weixin_43498449/article/details/124628513

版权

大数据之javase基础专栏收录该内容

29 篇文章 7 订阅

订阅专栏

1. 笔记

1.1 设计模式

1. 设计模式 ★
     23种-->就是前辈智慧的结晶(换一种方式实现功能)
     1.1 单例模式
         一个类对外只提供一个对象！
             a. 构造器私有化(不让外界new对象)
             b. 在本类内实例化一个对象，然后让外界可以获取到
         ① 懒汉式
             方式四属于懒汉式
                 特点：只有你要的时候，我才给你准备对象
         ② 饿汉式
             方式一二三属于饿汉式
                 特点：不管你要不要，类加载的时候，对象已经准备好

1.2 枚举

1. 枚举
    一个类对外提供固定个数的对象！
    1.1 JDK1.5之前    通过自己的逻辑
         a. 必须将构造器私有化
         b. 需要设置若干个公有的静态的常量
             类中的对象，一定要设置为常量！不能被修改
             类中如果有属性，属性不能提供set方法！(属性也不允许修改)

    1.2 JDK1.5之后
         引入了一个关键字enum,通过该关键字创建的类就是枚举类！
         语法：【修饰符】 enum 类名{}
         特点：
             ① 枚举类的构造器默认是私有的，并且必须是私有的！
             ② 直接写对象名即可(对象与对象之间采用逗号隔开，最后使用分号结束)！
             ③ 默认是采用无参构造器(后期可以设置)
             ④ 对象默认就是公有的静态的常量
             ⑤ 对象列表必须在类的首行
             ⑥ 如果显示的创建了有参构造器，没有无参构造器了
                对象的创建就需要使用有参构造器
                每个对象后添加小括号！

         枚举类的父类
             枚举类存在一个默认的父类Enum
                 方法：
                     name();  获得对象的名称
                     toString();  返回也是对象的名称
                         自定义的枚举类是可以再次重写的！
                     ordinal();返回当前对象的位置(角标)
                     static values();返回该枚举类所有的常量对象
                     static valueOf(String name);根据字符串的名称，返回常量对象
         实现接口
             语法： implements 接口名
             特殊点：
                 枚举类提供的对象个数是确定的！
                 并且在类加载的时候，对象就已经产生！
                 所以，抽象方法的实现，可以将范围缩小到某个对象！
                 语法：常量对象【(实参列表)】{对父级做扩展}   类似于匿名内部类的写法
                 当当前枚举类中所有的常量对象，都对抽象方法做了实现，
                 那么公有的就可以删除
     练习：
         1. 定义季节的枚举类，然后并设置属性value（对季节的描述）！在测试类测试！
         2. 定义星期的枚举类，然后并设置属性value（要做的事情）！在测试类测试！
         3. 手动输入一个星期的名称(常量名)，返回星期的常量对象！输出其value值！

1.3 注解

1. 注解
         注释：不参与编译和运行，是对代码的解释
         注解：参与编译和运行的，具有功能的
     1.1 注解的形式
         @注解名【(参数)】
     1.2 之前遇到的注解
         文档注释内(了解)：
             @author   作者
             @version   版本
             @param   参数
             @return  返回值
             ...
         注释外(掌握)：
             @Override  添加在方法的上方
                 功能：检测当前方法是否满足重写
                 源码：
                     @Target(ElementType.METHOD)
                         记录该注解可以应用在什么地方！
                     @Retention(RetentionPolicy.SOURCE)
                     public @interface Override {
                     }
             @Overload 重载
             @Deprecated  标记当前方法已过时
                 功能还是存在的，只是不再维护！(在后期升级不再考虑)
             @SuppressWarnings({"unused","rawtypes", "unchecked"})
                 抑制警告(idea中还好)  警告黄线(无所谓)，错误是红线(不允许出现)

        后期会学到很多的注解(注解开发是趋势)

1.4 单元测试

1. 单元测试  junit(第三方产品)
    main方法也是可以测试的，但是有一个弊端就是一个类允许存在一个main方法
    单元测试，一个类中可以创建多个程序的入口！

    前提：
        ① 必须使用在公有的类以及公有的方法上
        ② 需要导包(将第三方产品的源码导入到本项目内)
            在注解后面使用万能提示，选择junit4，导入(第一次下载会慢一些)
            手动导入(暂时的)：
                a. 需要去网络自己下载jar包(class文件的压缩包)
                    junit-4.12.jar
                    hamcrest-core-1.3.jar
                b. 在模块下new-->目录(lib)
                c. 将刚刚下载的jar包粘贴进去
                d. 在jar包上右键-->  add as library
        @Test   要求你的项目中么有自定义的Test类  ★
        @Before   每个Test之前运行
        @After    每个Test之后运行
        @BeforeClass  在所有的Test之前运行一次
            方法必须是静态
        @AfterClass   在所有的Test之后运行一次
            方法必须是静态
    缺点：
        ① 默认不能手动输入
        ② 学IO流的时候，关于相对路径也是有自己的特点
        ③ 不能够启动线程

1.5 包装类

1. 包装类
    1.1 主要是对基本数据类型的包装！
        基本数据类型效率高！但是后期的知识有一部分是针对于面向对象设计的！
        比如：
            泛型就不能指定基本数据类型
            集合中是不允许存储基本数据类型(只能存储对象)
        个数：8个
        byte        Byte
        short       Short
        int         Integer
        long        Long
        float       Float
        double      Double
                上述六个和数值有关的父类是  Number
        char        Character
        boolean     Boolean
                这两个的父类时Object
   1.2 使用
      装箱:
        基本数据类型-->包装类类型
        手动装箱：
            构造器
        自动装箱：
            直接赋值
      拆箱
        包装类类型-->基本数据类型
        手动拆箱：
            调用方法  xxxValue();
        自动拆箱：
            直接赋值

    1.3 包装类的常用方法
         a. 如何将字符串转为基本数据类型 ★
                String str="45";  转为int值
             ① 通过包装类的构造器
                int i = new Integer(str);
             ② 通过包装类的静态方法
                包装类的类名.parseXX(String)
         b. 最值
            Integer.MAX_VALUE和Integer.MIN_VALUE

    1.4 自动装箱的原理
        Integer i=10;//自动装箱  会默认调用Integer中的valueOf方法
              自动装箱的核心(源码)
                public static Integer valueOf(int i) {
                    if (i >= IntegerCache.low && i <= IntegerCache.high)
                        return IntegerCache.cache[i + (-IntegerCache.low)];
                    return new Integer(i);
                }
        包装类对比相等
            如果在默认值范围内，的自动装箱，则相等！
            一旦有自己new的就不相等
            如果不在范围内也是不相等的！
            如果有基本数据类型参与对比，包装类类型就会自动拆箱，就变为了基本数据              类型的对比!  只要值是一样的，就是相等的

2. 练习

2.1 枚举类型常用方法示例代码

public class TestEnum {
	public static void main(String[] args) {
		Season[] values = Season.values();
		for (int i = 0; i < values.length; i++) {
			switch(values[i]){
			case SPRING:
				System.out.println(values[i]+":春暖花开，万物复苏");
				break;
			case SUMMER:
				System.out.println(values[i]+":百花争艳，郁郁葱葱");
				break;
			case AUTUMN:
				System.out.println(values[i]+":菊桂飘香，百树凋零");
				break;
			case WINTER:
				System.out.println(values[i]+":梅花独开，大地一色");
				break;
			}
		}
	}
}
enum Season{
	SPRING,SUMMER,AUTUMN,WINTER
}

2.2 枚举类实现接口：

枚举类也是类，可以实现接口，可以同时实现多个接口。可以统一实现，也可以用匿名内部类的形式，单独给某个常量对象实现抽象方法。

interface Windiness{
	void wind();
}
enum Season implements Windiness{
	SPRING,SUMMER(){
		public void wind(){
			System.out.println("刮台风");
		}
	},AUTUMN,WINTER;
	public void wind(){
		System.out.println("刮风");
	}
}

2.3 注解示例代码

public class TestAnnotation {
	@SuppressWarnings({"unused","rawtypes", "unchecked"})
	public static void main(String[] args) {
		
		int i;
	
		List list = new ArrayList();
		list.add("");
		list.add(123);
		list.add("");
		
		Father f = new Son();
		f.show();
		f.methodOl();
	}

}


class Father{
	@Deprecated
	public void show() {
		
	}
	public void methodOl() {
		System.out.println("Father Method");
	}
	public void print1n(){
		System.out.println("Father Method");
	}
	public int sum(int... nums){
		int sum = 0;
		for (int i = 0; i < nums.length; i++) {
			sum += nums[i];
		}
		return sum;
	}
}

class Son extends Father{
	
/*	@Override
	public void method01() {
		System.out.println("Son Method");
	}
	
	@Override
	public void println(){
		System.out.println("Father Method");
	}
	
	@Override
	public long sum(int[] nums){
		int sum = 0;
		for (int i = 0; i < nums.length; i++) {
			sum += nums[i];
		}
		return sum;
	}*/
}