Java学习Day21(第十，十一章)（枚举，注解（没听懂），集合）
第十章 枚举类与注解
10.1 枚举类的使用
package atguigu.java;
/**
* 一、枚举类的使用
* 1.枚举类的理解：类的对象只有有限个，确定的，我们称此类为枚举类
* 2.当需要定义一组常量时，强烈建议使用枚举类
* 3.如果枚举类中只有一个对象，则可以作为单例模式的实现方式、
*
* 二、如何定义枚举类
* 方式一：jdk5.0之前自定义枚举类
* 方式二：jdk5.0,可以使用enum关键字定义枚举类
*
* 三、Enum类中的常用方法
* values():
* valuesof():
* toString():
*
* 四、使用enum关键字定义的枚举类实现接口的情况
* 情况一：实现接口，在enum类中实现抽象方法
* 情况二：
* @author xq
* @create 2020-12-26-10:54
*/
public class SeasonTest {
public static void main(String[] args) {
Season spring = Season.SPRING;
}
}
//自定义枚举类
class Season{
//声明Season对象的属性:private final
private final String seasonName;
private final String seasonDesc;
//1.私有化类的构造器
private Season(String seasonName,String seasonDesc){
this.seasonDesc = seasonDesc;
this.seasonName = seasonName;
}
//3.提供当前枚举类的多个对象:public static final的
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("冬天", "冰天雪地");
//4.其他诉求：获取枚举类对象的属性
public String getSeasonName() {
return seasonName;
}
public String getSeasonDesc() {
return seasonDesc;
}
//4.其他诉求：提供toString()
@Override
public String toString() {
return "Season{" +
"seasonName='" + seasonName + '\'' +
", seasonDesc='" + seasonDesc + '\'' +
'}';
}
}
package atguigu.java;
/**
* 使用enum关键字来定义枚举类
* 说明：定义的枚举类默认继承于java.lang.Enum类
*
* @author xq
* @create 2020-12-26-11:09
*/
public class SeasonTest1 {
public static void main(String[] args) {
Season1 summer = Season1.SUMMER;
//toString()
System.out.println(summer.toString());
System.out.println("****************");
//values():
Season1[] values = Season1.values();
for (int i = 0; i < values.length; i++) {
System.out.println(values[i]);
}
//valueof(String bojName):返回枚举类中对象名是objName的对象
Season1 winter = Season1.valueOf("WINTER");
System.out.println(winter);
}
}
//使用enum关键字枚举类
enum Season1{
//3.提供当前枚举类的多个对象,多个对象之间用","隔开，末尾对象分号结束
SPRING("春天", "春暖花开"),
SUMMER("夏天", "夏日炎炎"),
AUTUMN("秋天", "秋高气爽"),
WINTER("冬天", "冰天雪地");
//声明Season1对象的属性:private final
private final String Season1Name;
private final String Season1Desc;
//1.私有化类的构造器
private Season1(String Season1Name,String Season1Desc){
this.Season1Desc = Season1Desc;
this.Season1Name = Season1Name;
}
//4.其他诉求：获取枚举类对象的属性
public String getSeason1Name() {
return Season1Name;
}
public String getSeason1Desc() {
return Season1Desc;
}
//4.其他诉求：提供toString()
// @Override
// public String toString() {
// return "Season1{" +
// "Season1Name='" + Season1Name + '\'' +
// ", Season1Desc='" + Season1Desc + '\'' +
// '}';
// }
}
注解（Annotation）
代码里的特殊标记，可以在编译，类加载，运行时被读取，并执行相应的处理。
package com.atguigu.java1;
import org.junit.Test;
import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.Date;
/**
* 注解的使用
*
* 1. 理解Annotation:
* ① jdk 5.0 新增的功能
*
* ② Annotation 其实就是代码里的特殊标记, 这些标记可以在编译, 类加载, 运行时被读取, 并执行相应的处理。通过使用 Annotation,
* 程序员可以在不改变原有逻辑的情况下, 在源文件中嵌入一些补充信息。
*
* ③在JavaSE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在JavaEE/Android
* 中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替JavaEE旧版中所遗留的繁冗
* 代码和XML配置等。
*
* 2. Annocation的使用示例
* 示例一：生成文档相关的注解
* 示例二：在编译时进行格式检查(JDK内置的三个基本注解)
@Override: 限定重写父类方法, 该注解只能用于方法
@Deprecated: 用于表示所修饰的元素(类, 方法等)已过时。通常是因为所修饰的结构危险或存在更好的选择
@SuppressWarnings: 抑制编译器警告
* 示例三：跟踪代码依赖性，实现替代配置文件功能
*
* 3. 如何自定义注解：参照@SuppressWarnings定义
* ① 注解声明为：@interface
* ② 内部定义成员，通常使用value表示
* ③ 可以指定成员的默认值，使用default定义
* ④ 如果自定义注解没有成员，表明是一个标识作用。
如果注解有成员，在使用注解时，需要指明成员的值。
自定义注解必须配上注解的信息处理流程(使用反射)才有意义。
自定义注解通过都会指明两个元注解：Retention、Target
4. jdk 提供的4种元注解
元注解：对现有的注解进行解释说明的注解
Retention：指定所修饰的 Annotation 的生命周期：SOURCE\CLASS（默认行为）\RUNTIME
只有声明为RUNTIME生命周期的注解，才能通过反射获取。
Target:用于指定被修饰的 Annotation 能用于修饰哪些程序元素
*******出现的频率较低*******
Documented:表示所修饰的注解在被javadoc解析时，保留下来。
Inherited:被它修饰的 Annotation 将具有继承性。
5.通过反射获取注解信息 ---到反射内容时系统讲解
6. jdk 8 中注解的新特性：可重复注解、类型注解
6.1 可重复注解：① 在MyAnnotation上声明@Repeatable，成员值为MyAnnotations.class
② MyAnnotation的Target和Retention等元注解与MyAnnotations相同。
6.2 类型注解：
ElementType.TYPE_PARAMETER 表示该注解能写在类型变量的声明语句中（如：泛型声明）。
ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句中。
*
* @author shkstart
* @create 2019 上午 11:37
*/
public class AnnotationTest {
public static void main(String[] args) {
Person p = new Student();
p.walk();
Date date = new Date(2020, 10, 11);
System.out.println(date);
@SuppressWarnings("unused")
int num = 10;
// System.out.println(num);
@SuppressWarnings({ "unused", "rawtypes" })
ArrayList list = new ArrayList();
}
@Test
public void testGetAnnotation(){
Class clazz = Student.class;
Annotation[] annotations = clazz.getAnnotations();
for(int i = 0;i < annotations.length;i++){
System.out.println(annotations[i]);
}
}
}
//jdk 8之前的写法：
//@MyAnnotations({@MyAnnotation(value="hi"),@MyAnnotation(value="hi")})
@MyAnnotation(value="hi")
@MyAnnotation(value="abc")
class Person{
private String name;
private int age;
public Person() {
}
@MyAnnotation
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@MyAnnotation
public void walk(){
System.out.println("人走路");
}
public void eat(){
System.out.println("人吃饭");
}
}
interface Info{
void show();
}
class Student extends Person implements Info{
@Override
public void walk() {
System.out.println("学生走路");
}
public void show() {
}
}
class Generic<@MyAnnotation T>{
public void show() throws @MyAnnotation RuntimeException{
ArrayList<@MyAnnotation String> list = new ArrayList<>();
int num = (@MyAnnotation int) 10L;
}
}自定义注解
package com.atguigu.java1;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
/**
* @author shkstart
* @create 2019 上午 11:56
*/
@Inherited
@Repeatable(MyAnnotations.class)
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE,TYPE_PARAMETER,TYPE_USE})
public @interface MyAnnotation {
String value() default "hello";
}
第十一章：Java集合
11.1 Java集合框架概述
/** * 一、集合框架的概述 * * 1.集合、数组都是对多个数据进行存储操作的结构，简称Java容器 * 说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储（.txt,.jpg，数据库） * * 2.1.数组在存储多个数据方面的特点： * >一旦初始化以后，其长度就确定了。 * >数组一旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据量。 * 比如：String[] arr;int[] arr1; * 2.2 数组在存储多个数据方面的缺点： * >一旦初始化以后，其长度就不可修改 * >数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高 * >获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用 * >数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。 * * * * @author xq * @create 2020-12-26-15:48 */
package atguigu.java.java;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
/**
* 二、集合框架
* 1.Collection接口：单列集合，用来存储一个一个的对象
* 1.1List接口:存储有序的，可重复的数据。 ----->"动态"数组
* 1.1.1ArrayList,LinkedList,Vector
* 1.2Set接口：存储无序的，不可重复的数据 ------>数学上的集合
* 1.2.1HashSet,LinkedHashSet,TreeSet
* 2.Map接口：双列集合，用来存储一对（key-value）一对的数据 ----->函数
* 2.1 HashMap,LinkedHashMap,TreeMap,Hashtable,Properties
*
* 三、Collection接口中的方法的使用
*
*
* @author xq
* @create 2020-12-26-15:48
*/
public class CollectionTest {
@Test
public void test1(){
Collection coll = new ArrayList();
//add(Object):将元素e添加到集合coll中
coll.add("AA");
coll.add("BB");
coll.add(123);//自动装箱
coll.add(new Date());
//size():获取添加的元素的个数
System.out.println(coll.size());
//addAll(Collection coll1):将coll1集合中的元素添加到当前的集合中
Collection coll1 = new ArrayList();
coll1.add(456);
coll1.add("cc");
coll.addAll(coll1);
System.out.println(coll);
//clear():清空集合元素
coll.clear();
//isEmpty():判断当前集合是否为空
System.out.println(coll.isEmpty());
}
}
