JAVA004【常用API，自定义泛型、collection接口】

最新推荐文章于 2023-04-18 11:28:36 发布

KeepHadoop

最新推荐文章于 2023-04-18 11:28:36 发布

阅读量122

点赞数 1

分类专栏： Java学习之道文章标签： JAVA API 自定义泛型 collection接口

本文链接：https://blog.csdn.net/weixin_42615105/article/details/102413454

版权

Java学习之道专栏收录该内容

12 篇文章 0 订阅

订阅专栏

1.Date类概述

类Date表示特定的瞬间，精确到毫秒
作用：用来获取日期时间的信息，可以精确到毫秒值
- 1秒为1000毫秒
- Date() 获取当前时间对象
- Date(long time) 根据毫秒值创建日期对象
- long getTime()获取当前时间的毫秒从时间零点到当前时间经历的毫秒数：1970.1.1 00:00:00

2.DateFormat类:日期格式化类

Date主要表示1970年到某个时间的毫秒值

这是一个抽象类不能直接创建对象只能创建子类对象

常用子类：SimpleDateFormat

SimpleDateFormat类常用构造方法
    * SimpleDateFormat() 创建日期格式化对象，使用默认日期模式
    * SimpleDateFormat(String pattern)
        * 根据日期模式创建日期格式化对象

作用：

DateFormat类常用方法的两个方法
    * String format(Date date):日期转字符串
    * Date parse(String str)：字符串转日期

例子：

//日期转换为字符串
Date now = new Date();
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-mm-dd hh-mm-ss");
        String s=dateFormat.format(now);
        System.out.println(s);
//字符串转换为日期
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-mm-dd");
        Date d=dateFormat.parse("2000-10-10");
        System.out.println(d);

3.Calendar 日历

Calendar 类是一个抽象类：不能创建对象只能创建子类对象
get set add正数向后偏移
注意：month 获取是0到11 需要加1才是中国的
通过此类的静态方法创建日历对象：Calendar c= Calendar.getInstance() 获取日历对象
- 相对于 Calendar c=new GregorianCalendar 中国

1. Calendar的作用
   非常方便的可以获取到年月日时分秒,昨天,前天,明天,上个星期,上个月,前几年…
   可以方便的调整时间

2. 如何创建Calendar对象
   * Calendar类是一个抽象类：不能创建对象，只能创建子类对象
   * 通过Calendar类的静态方法创建日历对象，该方法如下：
       * static Calendar getInstance()  获得日历对象

3. Calendar类常用方法
    int get(int field)：
       根据指定的日历字段获得对应的值
       常用日历字段：YEAR/MONTH/DATE/HOUR/MINUTE/SECOND

    void set(int field, int value)
       修改指定日历字段的值为指定值value

    void add(int field, int amount)
       将指定日期字段的值在当前值基础上加减一个值：amount
        amount：正数，代表向前偏移
        amount：负数，代表向后偏移

4 .Calendar注意事项
    MONTH: 获得月份取值范围0到11，需要加1才是我们中国正确的月份
    DAY_OF_WEEK: 取值范围1到7  1代表周日，2代表周一,.....

ublic class Demo03 {
    public static void main(String[] args) {
        /*
          Calendar类静态方法源码分析：
            static Calendar getInstance(){
                return new GregorianCalendar();
            }
         */
        // 创建日历对象
        Calendar c = Calendar.getInstance(); // Calendar c = new GregorianCalendar();

        // 修改年份
        // c.set(Calendar.YEAR, 2018);
        // 修改月份
        // c.set(Calendar.MONTH, 11);


        // 将年份向前偏移1年
        // c.add(Calendar.YEAR, 1);
        // 将月份向后偏移2个月
        // c.add(Calendar.MONTH, -2);

        // java.util.GregorianCalendar
        // 获得年份
        System.out.println(c.get(Calendar.YEAR));
        // 获得月份
        System.out.println(c.get(Calendar.MONTH) + 1);
        // 获得日
        System.out.println(c.get(Calendar.DAY_OF_MONTH));
        // 获得周几
        System.out.println(c.get(Calendar.DAY_OF_WEEK));
    }
}

4.System工具类中常用方法

currentTimeMillis() arraycopy（）

static long currentTimeMillis()
    获得当前时间的毫秒值

static void arraycopy(Object src, int srcPos,
Object dest, int destPos, int length)
    * 数组复制
    * src   源数组
    * srcPos 源数组的起始索引
    * dest   目标数组
    * destPos  目标数组的起始索引
    * length   要复制元素的个数

public class Demo051 {
    public static void main(String[] args) {
        // test01();

        test02();
    }

    /*
      static void arraycopy(Object src, int srcPos,
        Object dest, int destPos, int length)
            * 数组复制
            * src   源数组
            * srcPos 源数组的起始索引
            * dest   目标数组
            * destPos  目标数组的起始索引
            * length   要复制元素的个数
     */
    private static void test02() {
        // 源数组
        int[] src = {1,2,3,4,5,6,7};
        // 目标数组
        int[] dest = new int[7];

        System.out.println(Arrays.toString(src));
        System.out.println(Arrays.toString(dest));

        System.out.println("------------------------");
        // 将数组src元素复制dest数组中
        // System.arraycopy(src, 0, dest, 0, 6);
        System.arraycopy(src, 1, dest, 1, 6);

        System.out.println(Arrays.toString(src));
        System.out.println(Arrays.toString(dest));
    }

    /**
     * currentTimeMillis：获得当前时间毫秒值
     */
    private static void test01() {
        // 获得开始时间：毫秒值
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            System.out.println("i = " + i);
        }
        // 获得结束时间：毫秒值
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}

5. BigDecimal类

1. BigDecimal类的作用
    用于解决小数不能进行精确数学运算的问题
    可以实现小数之间的精确数学运算。

2. BigDecimal类常用构造方法
    BigDecimal(String val)

3. BigDecimal类常用方法
    *  BigDecimal  add(BigDecimal b)  两个数相加
    *  BigDecimal  divide(BigDecimal b) 两个数相除
    *  BigDecimal  subtract(BigDecimal b)  两个数相减
    *  BigDecimal  multiply(BigDecimal b)  两个数相乘

public class Demo061 {
    public static void main(String[] args) {
       /* double a = 4.54;
        double b = 1.51;
        double c = a + b;
        System.out.println(1.5 + 2.5);*/

       // 创建BigDecimal对象
        BigDecimal a = new BigDecimal("1.0");
        BigDecimal b = new BigDecimal("3.0");

        // 进行加减乘除运算
        System.out.println("a + b = " + a.add(b));
        System.out.println("a - b = " + a.subtract(b));
        System.out.println("a * b = " + a.multiply(b));
        System.out.println("a / b = " + a.divide(b,new MathContext(3, RoundingMode.HALF_EVEN)));
    }
}

6.StringBuilder

1. StringBuilder是什么
    StringBuilder：可变字符串
    String：不可变字符串

2. 为什么使用StringBuilder
    解决字符串拼接耗性能问题：耗时间和耗内存

4. StringBuilder类常用方法
    StringBuilder append(数据类型 变量名)
        * 追加数据
    String toString();
        * 将可变字符串转换为不可变字符串
public class Demo071 {
    public static void main(String[] args) {
        // 创建可变字符串对象
        StringBuilder sb = new StringBuilder();
        /*sb.append(100);
        sb.append(1.5);
        sb.append(true);
        sb.append("abc");*/

        // 链式编程：当一个方法的返回值是一个对象时可以继续调用该对象的方法
        sb.append(100).append(1.5).append(true).append("abc");
        System.out.println(sb.toString());
    }
}

/**
    目标：String和StringBuilder性能测试

    小结：
        StringBuilder和String类的选择
            如果需要进行大量的字符串拼接，则选择StringBuilder
            
 */
public class Demo072 {
    public static void main(String[] args) {
        // String str = "";
        StringBuilder sb = new StringBuilder();
        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++) {
            // str += i;
            sb.append(i);
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start); //  5

    }
}

7.包装类名称

基本数据类型功能及其有限
- 为了实现更多的操作 java为每种数据类型提供了对应的类> 包装类
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character

boolean Boolean

作用

1将字符串转换为对应的基本数据类型

String y=“100”

int x=Integer.parseInt(y)

2将基本数据类型转换为字符串类型

int n=100;

sout(Integer.toString(n))

        八种基本数据类型与对应的包装类名称
             byte                Byte
             short               Short
             int                 Integer
             long                Long
             float               Float
             double              Double
             char                Character
             boolean             Boolean

            基本数据类型的首字母大写,特别的2个Integer, Character

        包装类常用操作
            1. 将字符串转换为对应的基本数据类型。
            2. 将基本数据类型转换为字符串类型。

    小结：
        8种基本数据类型：byte short int long float double char boolean
        8种包装类类名： Byte  Short Integer Long Float Double Character Boolean
 */
public class Demo81 {
    public static void main(String[] args) {
        //  1. 将字符串转换为对应的基本数据类型。
        String price = "100";
        String pre = "8.5";

        // 将字符串转换为整型数据
        int price01 = Integer.parseInt(price); // 100
        // 将小数字符串转换为浮点型
        double pre02 = Double.parseDouble(pre); // 8.5

        System.out.println(price01 * pre02);

        // 2. 将基本数据类型转换为字符串类型
        int num01 = 200;
        // 任何内容和字符串拼接都是字符串
        System.out.println(num01 + "");
        System.out.println(Integer.toString(num01)  + 1); // "2001"
        System.out.println(Double.toString(0.85) + 1); // 0.851
    }
}

8.自动装箱和自动拆箱 JDK1.5特性

包装类类型的数据和基本数据可以直接参与数据运算

自动拆箱
- 包装类转基本数据类型 Integer int
  - JDK1.5之前 Integer x=Integer.valueOf(200) int y=x.intValue()
  - 1.5之后 int y=x // int y=x.intValue()

自动装箱

int Integer

1.5之前 int x=100; Integer y=Integer.valueOf(x)//new Integer(x)过时了
1.5之后 Integer y=x;

package com.itheima._09自动拆装箱;

import java.util.ArrayList;

/**
    目标：能够说出自动装箱和自动拆箱的概念

    讲解：
        自动装箱和自动拆箱概述
            JDK1.5新特性

        什么是自动拆箱：
                Java编译器自动将包装类类型的数据转换为对应基本数据类型的过程。
                比如：Integer ==> int
                比如：Double ==> double

        什么是自动装箱:
                Java编译器自动将基本数据类型转换对应的包装类类型的过程
                比如：int ==> Integer

        自动装箱和自动拆箱的好处
            * 包装类类型的数据和基本数据可以直接参与数据运算

        思考：什么时候会触发自动装箱和自动拆箱？
            自动装箱：等号左边是包装类类型，等号右边是基本数据类型
                    Integer num = 100;
            自动拆箱：等号左边是基本数据类型，等号右边是包装类类型
                    Integer a = Integer.valueOf(200);
                    int num = a; // a.intValue();

        装箱和拆箱演示
            int --> Integer
            Integer --> int
    小结
        1.什么是自动装箱：自动将基本数据类型转换对应的包装类类型
        2.什么是自动拆箱：自动将包装类类型转换为基本数据类型
 */
public class Demo091 {
    public static void main(String[] args) {
        // int --> Integer
        // JDK1.5之前的做法
        int num01 = 100;
        int a = num01;

        Integer num02 = Integer.valueOf(num01); // new Integer(num01)
        Integer b = num02;

        // JDK1.5之后的做法
        // 自动装箱
        Integer num03 = num01; // Integer.valueOf(num01);

        // Integer --> int
        Integer num04 = Integer.valueOf(200);
        // JDK1.5之前的做法
        int num05 = num04.intValue();
        // JDK1.5之后的做法
        // 自动拆箱
        int num06 = num04; // int num06 = num04.intValue();
        System.out.println(num06 + num01); // 300
        // 自动装箱和拆箱的好处：包装类类型的数据和基本数据可以直接参与数据运算
        // Integer result = Integer.valueOf(num04.intValue() * num01)
        Integer result = num04 * num01;
        System.out.println(result);

        System.out.println("--------------");
        // 创建集合存储整型数据
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2); // 自动装箱
        list.add(Integer.valueOf(4));
        list.add(3);

        int num = list.get(0); // 自动拆箱
    }
}

9.集合和数组

一个用来存储多个元素的容器

集合和数组的区别

数组长度固定数组可以存储基本数据类型也可以存储引用数据类型
集合长度可变只能存储引用数据类型（猪狗猫对象）如果存储基本数据类型需要使用对应的包装类类型
元素个数固定用数组否则用集合

package com.itheima._10集合概述;

import java.util.ArrayList;

/**
    目标：能够说出集合和数组的区别

    讲解：
        1. 什么是集合(回顾)
            一个用来存储多个元素的容器

        2. 集合和数组的区别
            数组长度固定，数组可以存储基本数据类型，也可以储存引用数据类型
            集合长度可变，只能存储引用数据类型，如果要存储基本数据类型需要使用对应的
                包装类类型。

        3. 集合的分类
            Collection ---> 接口  所有单列集合的父类
                List   ---> 子接口
                    ArrayList
                    LinkedList
                Set    ---> 子接口
                    HashSet
                    LinkedHashSet
    小结：
        1. 集合和数组的区别
            集合：长度可变，只能存储引用数据类型
            数组：长度固定，可以存储基本数据类型和引用数据类型

        2. 如何选择集合和数组
            判断元素个数是否规定，如果是则可以选择数组，否则选择集合。
 */
public class Demo10 {
    public static void main(String[] args) {
        int[] arr = {1,2,3};
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
    }
}

10.Collection接口

分类 Collection 接口所有集合的父类

List 子接口 ArrayList LinkedList
Set 子接口 HashSet LinkedHashSet

package com.itheima._11Collection概述;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

/**
    目标：掌握Collection集合的常用功能(方法)

    讲解：
        1. Collection集合常用方法
             public boolean add(E e) ： 把给定的对象添加到当前集合中 。
             public void clear() :清空集合中所有的元素。
             boolean remove(E e) : 将给定的对象从集合中删除。
             boolean contains(E e) : 判断当前集合中是否包含给定的对象。
             public boolean isEmpty() : 判断当前集合是否为空。
             public int size() : 返回集合中元素的个数。
             public Object[] toArray() : 把集合中的元素，存储到数组中。

    小结
        1. Collection集合常用功能有哪些？
             add
             remove
             clear
             contains
             isEmpty
             size
             toArray
 */
public class Demo11 {
    public static void main(String[] args) {
        // 创建集合对象
        Collection<String> list =  new ArrayList<>();
        // public boolean add(E e) ： 把给定的对象添加到当前集合中 。
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        System.out.println(list); // [aaa, bbb, ccc]

        // boolean remove(E e) : 将给定的对象从集合中删除。
        System.out.println(list.remove("ccc")); // true
        System.out.println(list); // [aaa, bbb]

        // boolean contains(E e) : 判断当前集合中是否包含给定的对象。
        System.out.println(list.contains("bbb")); // true

        // public boolean isEmpty() : 判断当前集合是否为空。
        System.out.println(list.isEmpty()); // false

        // public int size() : 返回集合中元素的个数。
        System.out.println(list.size()); // 2

        // public Object[] toArray() : 把集合中的元素，存储到数组中。
        // Object[] objs = new Object[list.size()]
        // return objs;
        Object[] objs = list.toArray();
        System.out.println("objs ==> " + Arrays.toString(objs));

        // public void clear() :清空集合中所有的元素。
        list.clear();
        System.out.println(list); // []


    }
}

11.泛型

A.泛型回顾

package com.itheima._12泛型回顾;

import java.util.ArrayList;

/**
    目标：理解集合中使用泛型的好处

    讲解：
        1. 集合不使用泛型存在问题
            集合可以存储任意类型的数据，在遍历集合获取元素时，元素类型都是Object类型
            如果要调用子类特有的方法，需要向下转型，且还需要做判断。

        2. 集合使用泛型的好处
            * 将运行时错误转换为编译时错误。
            * 省去了数据类型转换的麻烦

    小结：
        1. 集合使用泛型的好处
             * 将运行时错误转换为编译时错误。
             * 省去了数据类型转换的麻烦
 */
public class Demo121 {
    public static void main(String[] args) {
        // 在JDK1.5之前：创建集合对象
        // ArrayList list = new ArrayList();

        // 在JDK1.5之后：创建集合对象
        ArrayList<String> list = new ArrayList();
        // 添加元素
        list.add("a");
        list.add("b");
        list.add("c");
        // list.add(123);

        // 使用普通for遍历
        for(int index = 0;index < list.size(); index ++){
           /* // 根据索引获得元素
            Object obj = list.get(index);
            // 向下转型为字符串
            String str = (String) obj;
            System.out.println(str.length());*/


            String str = list.get(index);
            System.out.println(str.length());
        }
    }
}

父类obj 不能用子类特有的方法之类的所以要向下转型
或者判断是否是String 用if（ obj instanceof String ）
加入泛型不需要做任何判断或者强制转换

B.泛型与泛型类

package com.itheima._13泛型类;

import java.util.Arrays;

/**
    目标：能够定义和使用泛型类

    讲解：
        1. 泛型概述
            * 概念：数据类型参数化，JDK1.5新特性
            * 泛型可以使用在方法上，类上，接口上。
            * 泛型变量命名规则：只要是合法的标识符就可以，但一般使用一个大写字母
                 常用的大小字母：T type，K key，V value，E element
            * 泛型变量可以理解为是某种数据类型的占位符


        2. 泛型类概念
            在定义类时定义了泛型变量的类

        3. 泛型类定义格式
            class 类名<T>{
                在类中可以将泛型变量T当成一种数据类型使用
            }

        4. 泛型类使用注意事项
            * 泛型变量的具体数据类型是由对象创建者在创建对象时指定。
            * 如果没有指定泛型变量的具体数据类型，则默认是Object

    小结：
        1. 泛型类定义格式：
            class 类名<泛型变量>{ }

        2. 如何使用泛型类
            创建泛型类对象时给泛型变量赋值
            格式：泛型类名<具体数据类型> 变量名 = new 泛型类名();
 */
public class Demo13 {
    public static void main(String[] args) {
        // 创建字符串数组
        String[] strs = {"1","2","3"};
        // 创建整型数组
        Integer[] ins = {4,5,6};

        // 创建MyArrays对象：指定泛型变量为String
        MyArrays<String> array01 = new MyArrays<>();
        array01.reverse(strs);

        // 创建MyArrays对象：指定泛型变量为Integer
        MyArrays<Integer> array02 = new MyArrays<>();
        array02.reverse(ins);

        // 创建MyArrays对象：不指定泛型变量类型
        MyArrays array03 = new MyArrays();
    }

    public static class MyArrays<T>{
        /**
         * 反转数组元素
         */
        public void reverse(T[] arr) {
            for(int i = 0,j = arr.length - 1;i < j; i++,j--) {
                T temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
            System.out.println(Arrays.toString(arr));
        }


        /**
         * 将数组元素拼接成字符串
         */
        public String toString(T[] arr) {
            StringBuilder sb = new StringBuilder("[");
            for (T t : arr) {
                sb.append(t).append(",");
            }
            sb.deleteCharAt(sb.length()-1);
            sb.append("]");
            return sb.toString();
        }
    }
}

C.泛型方法

package com.itheima._14泛型方法;

import java.util.Arrays;

/**
    目标：能够定义和使用泛型方法

    讲解：
        1. 泛型类的缺点：创建类对象时确定类型之后，只能使用这种类型了。

        2. 泛型方法的概念
            定义方法时定义了泛型变量的方法

        3. 泛型方法的定义格式
            修饰符 <T> 返回值类型 方法名(参数列表){
                可以将T当成一种数据类型在方法中使用：方法参数，方法返回值，方法体中
            }

        4. 泛型方法的注意事项
            * 泛型变量的具体数据类型时由调用者传参决定。
            * 泛型方法上定义的泛型变量一般都会使用在参数列表上
            * 静态方法不能使用类上定义的泛型变量，如果静态方法中需要使用泛型变量，则只能
                将该方法定义为泛型方法。
    小结：
        1.泛型方法的定义格式： 修饰符 <T> 返回值类型 方法名(参数列表){ }
        2.泛型方法的好处：可以让同一个方法处理多种类型的数据

 */
public class Demo14 {
    public static void main(String[] args) {
        // 创建字符串数组
        String[] strs = {"a","b"};
        // 创建整型数组
        Integer[] ins = {1,2,3};

        MyArrays.reverse(strs);
        MyArrays.reverse(ins);
        //static可以由类.方法

        System.out.println(Arrays.toString(strs));
        System.out.println(Arrays.toString(ins));
    }

    public static class MyArrays{
        /**
         * 反转数组元素：泛型方法
         */
        public static <E>  void reverse(E[] arr) {
            for(int i = 0,j = arr.length - 1;i < j; i++,j--) {
                E temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }


}

D.泛型接口

package com.itheima._15泛型接口;

/**
  泛型接口
  数据访问层：对数据库进程增删改查操作的
 */
public interface Dao<T> {
    void save(T t);
    void update(T t);
    void delete(int id);
    T findById(int id);
}

package com.itheima._15泛型接口;

/**
 * 实现接口时不指定泛型变量的具体数据类型，此时需要将实现类定义为泛型类
 */
public class BaseDao<T> implements  Dao<T> {
    @Override
    public void save(T t) {

    }

    @Override
    public void update(T t) {

    }

    @Override
    public void delete(int id) {

    }

    @Override
    public T findById(int id) {
        return null;
    }
}

package com.itheima._15泛型接口;

/**
    目标：能够定义和使用泛型接口

    讲解：
        1. 泛型接口概念
            在定义接口时定义了泛型变量的接口

        2. 泛型接口的定义格式
            interface 接口名<T>{
                在接口中可以将T当成一种数据类型使用
            }

        3. 泛型接口的实现方式
            * 方式1：实现接口同时指定泛型变量的具体数据类型
            * 方式2：实现接口时不指定泛型变量的具体数据类型，
                    此时需要将实现类定义为泛型类(推荐使用，比较灵活)
    小结：
        1.泛型接口的格式
            interface 接口<T>{ }

        2.泛型接口实现方式
             * 方式1：实现接口同时指定泛型变量的具体数据类型
             * 方式2：实现接口时不指定泛型变量的具体数据类型，
             此时需要将实现类定义为泛型类(推荐使用，比较灵活)
 */
public class Demo15 {
    public static void main(String[] args) {
        // 创建StudentDao类对象
        StudentDao stuDao = new StudentDao();
        stuDao.save(new Student());
        stuDao.findById(1);

        //  创建ProductDao类对象
        ProductDao productDao = new ProductDao();
        productDao.save(new Product());
        productDao.findById(1);

        // 创建BaseDao对象指定泛型变量：Student
        BaseDao<Student> dao01 = new BaseDao<>();
        dao01.save(new Student());

        // 创建BaseDao对象指定泛型变量：Product
        BaseDao<Product> dao02 = new BaseDao<>();
        dao02.save(new Product());

    }
}

package com.itheima._15泛型接口;

/**
 * 方式1：实现接口同时指定泛型变量的具体数据类型
 */
public class StudentDao implements Dao<Student> {

    @Override
    public void save(Student student) {
        System.out.println("保存学生...");
    }

    @Override
    public void update(Student student) {
        System.out.println("更新学生...");
    }

    @Override
    public void delete(int id) {
        System.out.println("根据id删除学生...");
    }

    @Override
    public Student findById(int id) {
        System.out.println("根据id查询学生...");
        return new Student();
    }
}

package com.itheima._15泛型接口;

public class ProductDao implements Dao<Product> {

    @Override
    public void save(Product product) {

    }

    @Override
    public void update(Product product) {

    }

    @Override
    public void delete(int id) {

    }

    @Override
    public Product findById(int id) {
        return null;
    }
}

package com.itheima._15泛型接口;

public class Student {
}



package com.itheima._15泛型接口;

public class Product {
}

12.泛型上下限通配符？

通配符？可以匹配任意类型的数据

package com.itheima._16泛型上下限;

import com.itheima._15泛型接口.Student;

import java.util.ArrayList;

/**
    目标：理解泛型通配符?的含义

    讲解：
        1. 多态语法回顾
            父类类型 变量名 = new 子类类名();

        2. 通配符?的含义：可以匹配任意类型的数据

        3. 泛型通配符使用场景演示
            * 需求：定义一个方法接收ArrayList集合，方法功能：遍历打印集合元素。

    小结：
        1. 泛型通配符?的含义：可以匹配任意类型的数据
 */
public class Demo161 {
    public static void main(String[] args) {
        // 多态语法：父类类型 变量名 = new 子类类名();

        // 在JDK1.7之前，两边的<>都必须写上数据类型，而且必须两边一致。
        // 在泛型中没有多态的概念
        ArrayList<Object> list01 = new ArrayList<Object>();
        ArrayList<String> list02 = new ArrayList<String>();
        ArrayList<Student> list03 = new ArrayList<Student>();

        ArrayList<?> list04 = new ArrayList<String>();
        ArrayList<?> list05 = new ArrayList<Double>();
        ArrayList<?> list06 = new ArrayList<Student>();

        printArrayList(list01);
        printArrayList(list02);
        printArrayList(list03);
        printArrayList(list04);
        printArrayList(list05);
        printArrayList(list06);
    }

    // 需求：定义一个方法接收ArrayList集合，方法功能：遍历打印集合元素。
    // ArrayList<?> list = new ArrayList<Object>();
    public static void printArrayList(ArrayList<?> list){
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

泛型上下限
- 泛型上限一根线上面不能传 <? extends Animal > 可以传递 animal的子类或者animal本身
- 泛型下限 <? super Animal > 可以传递animal的父类或者animal本身

通配符？注意事项

一般不会单独使用会结合泛型上下限使用哦
也不能用来定义泛型类方法变量

package com.itheima._16泛型上下限;

import java.util.ArrayList;

/**
    目标：理解泛型上下限含义

    讲解：
        1. Animal类型的继承体系
                  Object
                     |
                  Animal
                   /  \
                  /    \
                Dog    Cat

        2. 需求：
            * 定义方法接收ArrayList集合：存储动物对象。
            * 方法中遍历集合调用动物的eat方法。

        3. 泛型上限
            ? extends Animal ：可以传递Animal类型及其子类类型数据

        4. 泛型下限
            ? super Animal： 可以传递Animal类型及其父类类型数据

        5. 注意事项：
            * 通配符?一般不会单独使用，会结合泛型上下限使用。
            * 通配符?不能用来定义泛型类,泛型方法，泛型接口.

    小结：
        1. <? extends Animal> 的含义？ 泛型上限，可以传递Animal及其子类数据
        2. <? super Animal> 的含义? 泛型下限，可以传递Animal及其父类数据
 */
public class Demo162 {
    public static void main(String[] args){
        // 创建集合对象
        ArrayList<Object> list01 = new ArrayList<>();

        ArrayList<Animal> list02 = new ArrayList<Animal>();
        ArrayList<Dog> list03 = new ArrayList<>();
        ArrayList<Cat> list04 = new ArrayList<>();

        // feedAnimal(list01);
        feedAnimal(list02);
        feedAnimal(list03);
        feedAnimal(list04);

        feedAnimal02(list01);
        feedAnimal02(list02);
        // feedAnimal02(list03);
        // feedAnimal02(list04);
    }

    /*
     * 定义方法接收ArrayList集合：存储动物对象。
     * 方法中遍历集合调用动物的eat方法。
     */
    public static void feedAnimal02(ArrayList<? super Animal> list){
        for (int i = 0; i < list.size(); i++) {
            // 根据索引获得元素
            Object an = list.get(i);
            // an.eat();
        }
    }

    /*
     * 定义方法接收ArrayList集合：存储动物对象。
     * 方法中遍历集合调用动物的eat方法。
     */
    public static void feedAnimal(ArrayList<? extends Animal> list){
        for (int i = 0; i < list.size(); i++) {
            // 根据索引获得元素
            Animal an = list.get(i);
            an.eat();
        }
    }

}

15.总结

package com.itheima._17教学目标小结;

/**

 - 能够使用日期类输出当前日期
    Date d = new Date();

 - 能够使用将日期格式化为字符串的方法
       DateFormat类方法：String format(Date d) 日期转字符串

 - 能够使用将字符串转换成日期的方法
      DateFormat类方法：Date parse(String str) 字符串转换日期对象

    1. 创建日期格式对象并指定日期模式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    2. 调用日期格式对象的方法进行字符串和日期对象的相互转换
        * DateFormat类方法：String format(Date d) 日期转字符串
        * DateFormat类方法：Date parse(String str) 字符串转换日期对象

 - 能够使用System类的数组复制方法
    System.arraycopy(源数组,源数组起始索引,目标数组,目标数组起始索引,复制元素的个数)

 - 能够使用System类获取当前毫秒时刻值
    long time = System.currentTimeMillis();

 - 能够说出使用StringBuilder类可以解决的问题
    解决字符串拼接耗时间和耗内存的内容

 - 能够使用StringBuilder进行字符串拼接操作
    StringBuilder append(数据类型 变量名);

 - 能够说出8种基本类型对应的包装类名称
    除了int和char特殊，其他都是基本类型名称首字母大写即可
    int ==> Integer
    char ==> Character

 - 能够说出自动装箱、自动拆箱的概念
    自动装箱：自动将基本数据类型转换为包装类类型
    自动拆箱：自动将包装类类型转换为基本数据类型

 - 能够将字符串转换为对应的基本类型
    int num = Integer.parseInt("100");
    .....

 - 能够将基本类型转换为对应的字符串
    String str = Integer.toString(100);
    String str01 = 100+"";

 - 能够说出Collection集合的常用功能
    add
    remove
    clear
    contains
    isEmpty
    toArray
    size

 - 能够使用泛型创建集合对象
    ArrayList<String> list = new ArrayList<>()

 - 能够理解泛型上下限
    <? extends Animal>
    <? super Animal>

 - 能够阐述泛型通配符的作用
    ? ：可以匹配任意类型数据



 知识回顾
    多态格式：父类引用 变量名 = new 子类类名()
    多态的使用场景
        * 作为方法参数：可以接收多种子类类型的数据(对象)
        * 作为方法返回值：可以返回多种子类类型的数据(对象)
    多态的转型
        向上转型：父类引用 变量名 = new 子类类名()
        向下转型：子类类名 变量名 = (子类类名)父类引用
        instanceof：判断父类引用指向哪种子类类型的数据
        instanceof格式：boolean result = 父类引用 instanceof 子类类名;

    匿名内部类格式
        new 类名(){ }  直接创建已知类的子类对象
        new 接口名(){ } 直接创建已经接口的实现类对象

    静态代码块格式
        static { }  类加载时会自动执行1次，常用初始化资源

    Object类特点：所有类父类
        String toString();  默认返回格式：类全名字符串@对象地址值
        boolean equals(Object obj); 默认比较对象地址值判断

    今天
        1. 常用API：Application Progromming Interface 应用程序编程接口
            Date/DateFormat/Calendar/System/BigDecimal/StringBuilder/包装类
            自动装箱和自动拆箱
            Collection集合

        2. 泛型
            泛型在集合中的应用
            泛型类/泛型方法/泛型接口
            泛型上下限

KeepHadoop

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
JAVA004【常用API，自定义泛型、collection接口】

1.Date类概述类Date表示特定的瞬间，精确到毫秒作用：用来获取日期时间的信息，可以精确到毫秒值1秒为1000毫秒Date() 获取当前时间对象Date(long time) 根据毫秒值创建日期对象long getTime()获取当前时间的毫秒从时间零点到当前时间经历的毫秒数：1970.1.1 00:00:002.DateFormat类:日期格式化类Dat...
复制链接

扫一扫