1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package com.hong.Day007.Demo01;
/*
final关键字代表最终的、不可改变的
常见四种用法：
1.可以用来修饰一个类
格式：public fianl classs 类名称{}
含义：当前这个类不能有任何子类（太监类）（可以有父类，不能有子类）
2.可以用来修饰一个方法
格式：修饰符 final 返回值类型 方法名称(参数列表){方法体}
含义：当用fianl来修饰方法时，这个方法就是最终方法不能修改
3.还可以用来修饰一个局部变量
格式：修饰符 final 返回值类型 变量名 = 变量值
含义：当用fianl来修饰局部变量时，这个变量就是最终变量不能修改
（对于基本类型来说，不可变说的是变量当中的数据不可变
对于引用类型来说，不可变说的是变量当中的地址值不可变（数据值可以改变））
4.还可以用来修饰一个成员变量
含义：当用fianl来修饰成员变量时，这个变量就是最终变量不能修改
1.由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了
2.对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值
3.必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值
 */
public class Demo01 {
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package com.hong.Day007.Demo01;
/*
java中有四种权限修饰符：
           public > protected > (default) > private
同一个类       Yes       Yes         Yes        Yes
同一个包       Yes       Yes         Yes         No
不同包子类     Yes       Yes          No         No
不同包非子类   Yes        No          No         No

注意事项：(default)并不是关键字“default”，而是根本不写
 */
public class Demo02 {
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
package com.hong.Day007.Demo01;
/*
如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类。
分类：
1.成员内部类
定义格式:外部类名称$内部类名称
修饰符 class 类名称{
    修饰符 class 类名称{...}
      }
注意：内用外，随意访问;外用内，需要内部类对象
使用方法：
1.间接方法:在外部类的方法当中，使用内部类;然后main只是请用外部类的方法
2.直接方法:公式：
类名称 对象名 = new 类名称();
【外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称;】
3.如果出现了重名现象,那么格式是: 外部类名称.this.外部类成员变量名
==========================================================
2.局部内部类(包含匿名内部类)
定义格式:
修饰符 class 外部类名称{
    修饰符 返回值类型 外部类方法名称(参数列表){
        class 局部内部类名称{
        }
    }
}
注意:
1.如果希望访问所在方法的局部变量,那么这个局部变量必须是【有效final的】
2.定义一个类的时候,权限修饰符规则
  1.外部类:   public / (defualt)
  2.成员内部类:   public / protectted / (defualt) / private
  3.局部内部类:什么都不能写
============================================================
3.匿名内部类
如果接口的 实现类(或者是父类的子类)只需要使用唯一的一次
那么这种情况下就可以省略掉该类的定义,而改为使用【匿名内部类】
定义格式:
接口名称 对象名 = new 接口名称() {
     //覆盖重写所有抽象方法
};
注意事项:
1.匿名内部类,在【创建对象】的时候,只能使用唯一一次
2.匿名对象,在【调用方法】的时候,只能调用唯一一次
如果希望同一个对象,调用多次方法,那么必然要给对象起个名字
3.匿名内部类是省略了【实现类/子类名称】,但是匿名对象是省略了【对象名字】
*/
public class Demo03 {

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package com.hong.Day007.Demo02;

import java.util.ArrayList;

public interface OpenMode {
    /**
     * 请将totalMoney分成count份,保存到ArrayList<Integer>,返回
     * @param totalMoney           总金额为方便计算,已经转换为整数,单位为分
     * @param totalCount                   红包个数
     * @return ArrayList<Integer>   元素为各个红包的金额值，所有元素的值累和等于总金额
     */
    ArrayList<Integer> divide(int totalMoney,int totalCount);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package com.hong.Day007.Demo02;
/*
场景说明:
   红包发出去之后,所有人都有红包,大家抢完了之后,最后一个红包给群主自己
红包分发的策略:
     1.普通红包(平均):totalMoney / totalCount ,余数放在最后一个红包当中
     2.手气红包(随机):最少1分钱,最多不超过平均数的两倍,余额越发越少
 */
public class Bootstrap {
    public static void main(String[] args) {

    }
}

1
2
equals(Object obj)

1
2
toString()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
package com.hong.Day007.Demo02;

import java.util.Date;

/*
    java.lang.Date:表示日期和时间的类
    类 Date 表示特定的瞬间，精确到毫秒
    毫秒值的作用:可以对时间和日期进行计算(可以把日期转换成毫秒,把毫秒转换成日期)
把日期转换为毫秒:
     当前日期:2088-01-01
     时间原点(0毫秒):1970年 1 月 1 日 00:00:00(英国格林威治)
注意:
     中国属于东八区:
     时间原点(0毫秒):1970年 1 月 1 日 08:00:00
     把毫秒转换为日期:
     1天 = 24 * 60 * 60 = 86400秒 = 86400 * 1000毫秒
 */
public class Demo01{
    public static void main(String[] args) {
        //获取当前系统时间到1970年1 月 1 日 00:00:00经历了多少毫秒
        System.out.println(System.currentTimeMillis());
        //Data类的空参数构造方法(获取当前系统的日期和时间)
        getData();
        //Data类的带参数构造方法(传递毫秒值,返回Data日期值)
        System.out.println(changeData(0L));
        //getTime方法:把日期转换为毫秒
        Date date = new Date();
        System.out.println(date.getTime());
    }
    //Data类的空参数构造方法(获取当前系统的日期和时间)
    private static void getData() {
        Date date = new Date();
        System.out.println(date);
    }
    //Data类的带参数构造方法(传递毫秒值,返回Data日期值)
    private static Date changeData(long a) {
        Date date1 = new Date(a);
        return date1;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
package com.hong.Day007.Demo02;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/*
`DateFormat`是日期/时间格式化子类的抽象类
  作用:
    格式化(也就是日期-->文本)、解析(文本-->日期)
  成员方法:
     String format(Data data) 按照指定的模式,把Data日期,格式化为符合模式的字符串
     Data parse(String source) 把符合模式的字符串,解析为Data日期
  DateFormat类是一个抽象类,无法直接创建对象使用,可以使用DateFormat类的子类(SimpleDateFormat)
  构造方法:
      SimpleDateFormat(String pattern)
        用给定的模式和默认语言环境和日期格式符号构造
      参数:
        String pattern:传递指定格式
      模式:(大小写区分)
        y  年
        M  月
        d  日
        H  时
        m  分
        s  秒
 */
public class Demo02 {
    public static void main(String[] args) throws ParseException {
        texi01();
        texi02();
    }
    /*
      使用DataFormat类中的方法format,把日期格式转化为文本
     */
    private static void texi01() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        Date date = new Date();
        String d = sdf.format(date);
        System.out.println(date);
        System.out.println(d);
    }
    /*
      使用DataFormat类中的方法parse,把文本格式解析为日期
     */
    private static void texi02() throws ParseException{
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        Date deta = sdf.parse("2008年08月08日 15时51分54秒");
        System.out.println(deta);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
package com.hong.Day007.Demo02;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

/*
1.使用Scanner方法获得出生日期(2000年07月16日 05时21分12秒)
2.使用DateFormat中的parse方法把字符串的出生日期解析为Date格式的出生日期
3.把Date格式的出生日期转换为毫秒值
4.获取当前日期,转换为毫秒值
5.使用当前日期的毫秒值-出生日期的毫秒值
6.把毫秒值转换为天(s/1000/60/60/24)
 */
public class Demo03 {
    public static void main(String[] args) throws ParseException {
        System.out.print("请输入您的出生日期:");
        Scanner scanner = new Scanner(System.in);
        String godown = scanner.nextLine();
        Date a = getNow();
        Date b = toDate(godown);
        System.out.println("当前时间的:" + a);
        System.out.println("出生时间的:" + b);
        System.out.println("当前时间的毫秒值" + a.getTime());
        System.out.println("出生时间的毫秒值" + b.getTime());
        double c = (a.getTime() - b.getTime())/1000/60/60/24;
        System.out.println("出生天数:" + c + "天");
        scanner.close();
    }
    //获取当前日期,转换为毫秒值
    private static Date getNow() {
        Date date = new Date();
        return date;
    }
    //使用DateFormat中的parse方法把字符串的出生日期解析为Date格式的出生日期
    private static Date toDate(String godown) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        Date deta = sdf.parse(godown);
        System.out.println(deta);
        return deta;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package com.hong.Day007.Demo02;

import java.util.Calendar;

/*
    java.util.Calendar类:日历类
    Calendar类是一个抽象类,里面提供了很多操作日历字段的方法(YEAR、MONTH、DAY_OF_MONTH、HOUR)
    Calendar类无法直接创建对象使用,里面有一个静态方法叫getInstance(),该方法返回了Calendar类的子类对象
    static Calendar getInstance() 使用默认时区和语言环境获得一个日历
 成员方法的参数
 1.int get(int field)返回给定日历字段的值。
 2.void set(int year, int month, int date, int hourOfDay, int minute, int second)设置字段中的值 YEAR ， MONTH ， DAY_OF_MONTH ， HOUR_OF_DAY ， MINUTE和 SECOND 。
 3.abstract void add(int field, int amount)根据日历的规则，将指定的时间量添加或减去给定的日历字段。
 4.Date getTime()返回一个 Date表示此物体 Calendar的时间值（毫秒从偏移 Epoch “）。
 */
public class Demo04 {
    public static void main(String[] args) {
        Calendar c = Calendar.getInstance();//多态
        System.out.println(c);
        //get(int field)返回给定日历字段的值。(输出的月份为美历月份为0-11月)
        int year = c.get(Calendar.YEAR);
        System.out.println(year);
        //set(int year, int month, int date, int hourOfDay, int minute, int second)设置字段中的值 YEAR ， MONTH ， DAY_OF_MONTH ， HOUR_OF_DAY ， MINUTE和 SECOND 。
        c.set(Calendar.YEAR,9999);
        int year1 = c.get(Calendar.YEAR);
        System.out.println(year1);
        //add(int field, int amount)根据日历的规则，将指定的时间量添加或减去给定的日历字段。
        c.add(Calendar.YEAR,1);
        int year2 = c.get(Calendar.YEAR);
        System.out.println(year2);
        //Date getTime()返回一个 Date表示此物体 Calendar的时间值（毫秒从偏移 Epoch “）。
        System.out.println(c.getTime());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package com.hong.Day007.Demo02;

import java.util.Arrays;

/*
1.static long currentTimeMillis()返回当前时间（以毫秒为单位）。
练习:
    验证for循环打印数字1:9999所需要使用的世界(毫秒)
2.static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)将指定源数组中的数组从指定位置复制到目标数组的指定位置。
                              源数组  源数组的起始位置 目标数组  目标数组中的起始位置 要复制数组元素的数量
练习:
    将src数组中的前3个元素,复制到dest数组的前3个位置上
    复制元素前:src{1,2,3,4,5}  dest{6,7,8,9,10}
    复制元素后:src{1,2,3,4,5}  dest{1,2,3,9,10}
 */
public class Demo05 {
    public static void main(String[] args) {
        //验证for循环打印数字1:9999所需要使用的世界(毫秒)
        long s = System.currentTimeMillis();
        for (int i = 0; i < 9999; i++) {
            System.out.println(i);
        }
        long l = System.currentTimeMillis();
        System.out.println(l-s);

        //将src数组中的前3个元素,复制到dest数组的前3个位置上
        int[] src = {1,2,3,4,5};
        int[] dest = {6,7,8,9,10};
        System.arraycopy(src,0,dest,0,3);
        System.out.println(Arrays.toString(src));
        System.out.println(Arrays.toString(dest));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package com.hong.Day007.Demo03;
/*
StringBuilder()
构造一个没有字符的字符串构建器，初始容量为16个字符。可以提高字符串的效率
常用方法:
1.append()表示附加到序列中。可以是所有基本类型
2.capacity()返回当前容量。
3.charAt(int index)返回 char在指定索引在这个序列值。
4.delete(int start, int end)删除此序列的子字符串中的字符。
5.getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)字符从该序列复制到目标字符数组 dst 。
6.indexOf(String str)返回指定子字符串第一次出现的字符串内的索引。
7.length()返回长度（字符数）。
8.replace(int start, int end, String str)用指定的String中的字符替换此序列的子字符串中的 String 。
9.toString()返回表示此顺序中的数据的字符串。
 */
public class Demo01 {
    public static void main(String[] args) {
        //空参数构造
        StringBuilder bu1 = new StringBuilder();
        System.out.println("bu1:" + bu1);//默认空字符串

        //带参数构造
        StringBuilder bu2 = new StringBuilder("abc");
        System.out.println("bu2:" + bu2);//abc

        //常用方法
        //1.append()表示附加到序列中。可以是所有基本类型
        StringBuilder bu3 = bu2.append('c');
        System.out.println("bu3:" + bu3);
        //2.capacity()返回当前容量。
        System.out.println(bu3.capacity());
    }
}

1
2
3
4
5
6
7
8
9
10
11
/*
基本类型     包装类（引用类型）
 short      Short
 byte       Byte
 int        Integer
 long       Long
 float      Float
 boolean    Boolean
 char       Character
 */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.hong.Day007.Demo03;
/*
装箱:把基本类型的数据,包装到包装类中(基本类型-->包装类)
    构造方法:
        Integer(int value)构造一个新分配的 Integer对象，该对象表示指定的 int值。
        Integer(String s)构造一个新分配 Integer对象，表示 int由指示值 String参数。
    静态方法:
        static Integer valueOf(String s)返回一个 Integer对象，保存指定的值为 String 。
        static Integer valueOf(String s, int radix)返回一个 Integer对象，保存从指定的String中 String的值，当用第二个参数给出的基数进行解析时。
拆箱:在包装类中取出基本类型的数据(包装类-->基本类型)
    成员方法:
        int intValue()将 Integer的值作为 int 。
自动装箱与拆箱:基本类型的数据和包装类之间可以自动的相互转换
 */
public class Demo02 {
}

1
2
3
4
5
6
7
8
9
10
11
12
13
package com.hong.Day007.Demo03;
/*
     基本类型与字符串类型之间的相互转换
     基本类型-->字符串
         1.基本类型的值 + “ ” 最简单的方法
         2.包装类的静态方法toString(参数),不是Object类的toString()重载
         3.String类的静态方法valueOf(参数)
     字符串-->基本类型
         1.使用包装类的静态方法parseInt("字符串")
 */
public class Demo03 {
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
package com.hong.Day007.Demo03;

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

/*
Collection 常用功能
1.public boolean add(E e): 把给定的对象添加到当前集合中
2.public void clear: 从此集合中删除所有元素（可选操作）。
3.public boolean remove(Object o)从该集合中删除指定元素的单个实例（如果存在）（可选操作）。
4.public boolean contains(Object o)如果此集合包含指定的元素，则返回 true 。
5.public boolean isEmpty()如果此集合不包含元素，则返回 true 。
6.public int size()返回此集合中的元素数。
7.public Object[] toArray()返回一个包含此集合中所有元素的数组。
 */
public class Demo04 {
    public static void main(String[] args) {
        //创建集合对象,可以使用多态
        Collection<String> coll = new ArrayList<>();
        System.out.println(coll);//重写了toString方法

        //public boolean add(E e): 把给定的对象添加到当前集合中
        //返回值是一个boolean值
        coll.add("张三");
        coll.add("李四");
        coll.add("王五");
        coll.add("赵六");
        coll.add("田七");
        System.out.println(coll);

        //public boolean remove(Object o)从该集合中删除指定元素的单个实例（如果存在）
        coll.remove("赵六");
        System.out.println(coll.remove("赵四"));//false
        System.out.println(coll);

        //public boolean contains(Object o)如果此集合包含指定的元素，则返回 true 。
        System.out.println(coll.contains("赵四"));//false
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
package com.hong.Day007.Demo03;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/*
     java.util.Iterator
     有两个常用的方法:
         boolean hasNext() 如果任有元素可以迭代,则返回ture
         E next() 返回迭代下一个元素(取出集合的下一个元素)
     Iterator迭代器,是一个接口,Collectino接口中有iterator()方法用来返回迭代器的实现类对象
     迭代器的使用方法:
         1.使用集合中的方法(iterator)获取迭代器的实现类对象,使用Iterator接口接受(多态)
         2.使用Iterator接口中的方法hasNext判断还有没有下一个元素
         3.使用Iterator接口中的方法next取出集合中的下一个元素
 */
public class Demo05 {
    public static void main(String[] args) {
        //创建一个集合对象
        Collection<String> coll = new ArrayList<>();
        //往集合中添加元素
        coll.add("姚明");
        coll.add("科比");
        coll.add("麦迪");
        coll.add("詹姆斯");
        coll.add("艾弗森");
        /*
          1.使用集合中的方法(iterator)获取迭代器的实现类对象,使用Iterator接口接受(多态)
          注意:
            Iterator<E>接口也是有泛型的,迭代器的泛型跟着集合走，集合是什么泛型，迭代器就是什么泛型
         */
        //多态   接口            实现类对象
        Iterator<String> a = coll.iterator();
        //2.使用Iterator接口中的方法hasNext判断还有没有下一个元素
        //3.使用Iterator接口中的方法next取出集合中的下一个元素
        for (int i = 0; i < 5; i++) {
            if (a.hasNext()){
                System.out.println(" "+ a.next());
            }
        }
    }
}

1
2
3
4
for(元素的数据类型 变量 : Collection集合or数组){
    //写操作代码
}

1
2
3
4
5
6
7
8
public static void main(String[] args) {
    int[] arr = {3,5,6,87};
    //遍历数组
    for (int i : arr) {
        System.out.println(i);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
public static void main(String[] args) {
    ArrayList<Integer> arr = new ArrayList<>();
    arr.add(1);
    arr.add(2);
    arr.add(3);
    arr.add(4);
    //遍历数组
    for (int i : arr) {
        System.out.println(i);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/*
创建集合对象,不使用泛型
好处:
    集合不使用泛型,默认的类型就是Object类型,可以存储任意类型的数据
弊端:
    不安全,会引发异常

创建集合对象,使用泛型
好处:
    1.避免了类型转换的麻烦,存储的是什么类型,取出的就是什么类型
    2.把运行期异常(代码运行之后会抛出的异常),提升到了编译期(写代码的时候会报错)
弊端:
    泛型是什么类型,只能存储什么类型的数据
 */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package com.hong.Day007.Demo04;
/*
    定义一个含有泛型的类,模拟ArrayList集合
    泛型是一个未知的数据类型,当我们不确定使用什么数据类型的时候,可以使用泛型
    泛型可以接收任意的数据类型,可以使用Integer、Double、String......
    创建对象的时候确定泛型的数据类型
 */
public class Demo01<E> {
    private E name;

    public Demo01() {
    }

    public Demo01(E name) {
        this.name = name;
    }

    public E getName() {
        return name;
    }

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.hong.Day007.Demo04;

public class Demo02 {
    public static void main(String[] args) {
        //不写泛型默认为Object类型
        Demo01 demo01 = new Demo01();
        demo01.setName("只能是字符串");
        Object object = demo01.getName();

        //创建Demo01对象,泛型使用Integer类型
        Demo01<Integer> b = new Demo01<Integer>();
        b.setName(1);
        Integer name = b.getName();
        System.out.println(name);

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.hong.Day007.Demo04;
/*
     定义含有泛型的方法:泛型定义在方法的修饰符和值类型之间
     格式:
         修饰符 <泛型> 返回值类型 方法名(参数列表){方法体}
     含有泛型的方法,在调用方法的时候确定泛型的数据类型
 */
public class Demo03 {
    //定义一个含有泛型的方法
    public <M> void method(M m){
        System.out.println(m);
    }

    //定义一个含有泛型的静态方法
    public static <S> void method1(S s){
        System.out.println(s);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.hong.Day007.Demo04;

public class Demo04 {
    public static void main(String[] args) {
        //创建一个Demo03对象
        Demo03 a = new Demo03();
        a.method(1);
        a.method("a");
        a.method(true);
        a.method(10.0);

        a.method1("静态方法,不建议创建对象使用");
        //静态方法,通过类名.方法名(参数)直接使用
        Demo03.method1("静态方法");
        Demo03.method1(1);
    }
}

1
2
3
4
5
6
7
8
package com.hong.Day007.Demo04;
/*
    定义含有泛型的接口
 */
public interface Demo05<I> {
    public abstract void method(I i);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.hong.Day007.Demo04;
/*
    含有泛型的接口
    第一种使用方法:定义接口的实现类,实现接口,指定接口的泛型
    第二种使用方法:接口使用什么泛型,实现类就使用什么泛型
 */
public class Demo06 implements Demo05<String>{
    @Override
    public void method(String s) {
        System.out.println(s);
    }
}
//public class Demo06<I> implements Demo05<I>{
//    @Override
//    public void method(I i) {
//        System.out.println(i);
//    }
//}

1
2
3
4
5
6
7
8
9
10
package com.hong.Day007.Demo04;

public class Demo08 {
    public static void main(String[] args) {
        //创建对象
        Demo06 demo06 = new Demo06();
        demo06.method("第一种方法");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
package com.hong.Day007.Demo05;

import java.util.ArrayList;
import java.util.Iterator;

/*
    泛型的通配符:
        ? 代表任意的数据类型
    使用方法:
        不能创建对象使用
        只能作为方法的参数使用
 */
public class Demo01 {
    public static void main(String[] args) {
        ArrayList<Integer> list01 = new ArrayList<>();
        list01.add(1);
        list01.add(2);
        ArrayList<String> list02 = new ArrayList<>();
        list02.add("a");
        list02.add("b");
        printArray(list01);
        printArray(list02);
    }
    /*
    定义一个方法,能遍历所有类型的ArrayList集合(可以使用泛型通配符)
     */
    public static void printArray(ArrayList<?> list){
        System.out.println(list);
        Iterator<?> it = list.iterator();
        while (it.hasNext()){
            //it.next()取出的元素是Object
            Object o = it.next();
            System.out.println(o);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
/*
    泛型的上限限定:  ?  extends E  代表使用的泛型只能是E类型的子类/bens
    泛型的下限限定:  ?  super E    代表使用的泛型只能是E类型的父类/bens
    类与类之间的继承关系
    Integer extends Number extends Object
    String extends Object
*/
public class Demo02 {
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

### 泛型的上限和下限

```java
/*
    泛型的上限限定:  ?  extends E  代表使用的泛型只能是E类型的子类/bens
    泛型的下限限定:  ?  super E    代表使用的泛型只能是E类型的父类/bens
    类与类之间的继承关系
    Integer extends Number extends Object
    String extends Object
*/
public class Demo02 {
}