Java学习周记week03

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java学习周记week03相关的知识,希望对你有一定的参考价值。

一.继承

1.什么叫继承?

继承是面向对象的三大特征之一。

在程序中,继承描述的是类与类之间的关系,通过继承多个类之间形成一种关系体系。

在Java中,类的继承是指在一个现有类的基础上去构建一个新的类,构建出的类被称作子类,现有的类被称作父类。

继承后子类的特点: 子类自动拥有父类所有可继承的属性和方法。

在程序中,如果想声明一个类继承另一个类,需要使用extends关键字。

 

2.继承的注意事项

(1)继承必须合理(子类必须属于父类的一种时,符合is a 法则时,才会继承)

(2)父类中成员是共性的内容(父类抽取出了共性的内容,子类可以在父类基础上扩展新的属性和行为)

(3)子类自动拥有父类的成员并且可以直接使用非私有的父类成员

 

3.子类中访问父类成员变量特点

如果父类中的成员变量是非私有的,那么子类可以直接访问。

如果出现了成员变量同名的情况,在程序中使用子类对象会自动调用子类的成员变量,如果想调用父类的成员变量,需要使用super关键字。

 

4.子类中访问父类成员方法特点

当程序通过对象调用方法时,会先在子类中查找是否有对应方法,如果有的话就执行子类中的方法,如果没有的话就会执行父类中的对应方法。

在子类中,访问父类中的成员方法格式:

super.父类中的成员方法();

5.继承特点

1.Java只支持单继承:就一个子类  只能最多直接继承一个父类。(Java不支持多继承)

2.Java支持多层继承。

3.父类定义了继承树中共性内容,子类定义了该类个性内容。

 

6.继承中方法的重写与应用

子父类成员方法特殊情况——覆盖

子类中出现与父类一模一样的方法时,会出现覆盖操作,也称为override重写、复写或者覆盖。

当子类需要父类的功能,而功能主体子类有自己特有内容时,可以重写父类中的方法,这样,即沿袭了父类的功能,又定义了子类特有的内容。

 

7.方法重写的注意事项

  •  子类方法覆盖/重写/覆写(override)父类方法,必须要保证权限大于等于父类权限。

  •  如果父类的方法是private的修饰的,那么在子类中没法重写(其他修饰符都可以重写)。

  •  写法上稍微注意:必须一模一样:方法的返回值类型 方法名 参数列表都要一样。

总结:当一个类是另一个类中的一种时,可以通过继承,来继承属性与功能。如果父类具备的功能内容需要子类特殊定义时,进行方法重写。

 

二. 抽象类

1.抽象方法的产生与定义

 

 

分析事物时,发现了共性内容,就出现向上抽取。会有这样一种特殊情况,就是方法功能声明相同,但方法功能主体不同。那么这时也可以抽取,但只抽取方法声明,不抽取方法主体。那么此方法就是一个抽象方法。

 

当定义了抽象函数的类也必须被abstract关键字修饰,被abstract关键字修饰的类是抽象类。

 

 

1 抽象方法定义的格式:
2 public abstract 返回值类型 方法名(参数);
3 
4 抽象类定义的格式:
5 abstract class 类名 {
6 }

 

2.抽象方法的使用

 

抽象类无法直接创建对象,只能被子类继承后,创建子类对象。

 

 三.接口

1.接口的概念

 

类:具有相同属性和功能的事物集合

接口是功能的集合,同样可看做是一种数据类型,是比抽象类更为抽象的”类”。

接口只描述所应该具备的方法,并没有具体实现,具体的实现由接口的实现类(相当于接口的子类)来完成。这样将功能的定义与实现分离,优化了程序设计。

一切事物均有功能,即一切事物均有接口。

2.接口的定义

与定义类的class不同,接口定义时需要使用interface关键字。

定义接口所在的仍为.java文件,虽然声明时使用的为interface关键字的编译后仍然会产生.class文件。这点可以让我们将接口看做是一种只包含了功能声明的特殊类。

1 public interface 接口名 {
2 抽象方法1;
3 抽象方法2;
4 抽象方法3;
5 }

3.实现类接口

类与接口的关系为实现关系,即类实现接口。实现的动作类似继承,只是关键字不同,实现使用implements

   class 实现类 implements 接口 { 重写接口中所有方法 }  

在类实现接口后,该类就会将接口中的抽象方法继承过来,此时该类需要重写该抽象方法,完成具体的逻辑。

 

4.接口中成员的特点

 

1、接口中可以定义成员变量,但是变量必须有固定的修饰符修饰,public static final 所以接口中的变量也称之为常量,其值不能改变。后面我们会讲解static与final关键字

2、接口中可以定义方法,方法也有固定的修饰符,public abstract

3、接口不可以创建对象。

4、实现类必须覆盖掉接口中所有的抽象方法后,实现类才可以实例化。否则实现类是一个抽象类。

 

5.接口特点

 

接口可以继承接口。

如同类继承类后便拥有了父类的成员,可以使用父类的非私有成员。A接口继承B接口后,A接口便拥有了A、B两个接口中所有的抽象方法。

Java支持一个类同时实现多个接口,或一个接口同时继承多个接口。

类可以在继承一个类的同时,实现多个接口。

接口与父类的功能可以重复,均代表要具备某种功能,并不冲突。

 

6.抽象类与接口的比较

 

 

相同点:

 

  都位于继承的顶端,用于被其他类实现或继承;

  都不能直接实例化对象;

  都可以包含抽象方法,其子类都必须覆写这些抽象方法;

 

区别:

 

  抽象类为部分方法提供实现,避免子类重复实现这些方法,提高代码重用性;

  接口只能包含抽象方法;

  一个类只能继承一个直接父类(可能是抽象类),却可以实现多个接口;(接口弥补了Java的单继承) 

 抽象类为继承体系中的共性内容,接口为继承体系外的扩展功能

 

二者的选用:

 

  优先选用接口,尽量少用抽象类;

  需要定义子类的行为,又要为子类提供共性功能时才选用抽象类;

 四.多态

1.多态的概念

 

多态是继封装继承之后,面向对象的第三大特性。

父类引用变量可以指向子类对象。

多态的前提是必须有子父类关系或者类实现接口关系,否则无法完成多态。

在使用多态后的父类引用变量调用方法时,会调用子类重写后的方法。

 

2.多态的代码体现

 

 父类类型 变量名 = new 子类类型(); 

 

 

此时,虽然该变量指向的是子类对象,但表现为一个父类的形态,可以调用一切父类的方法,子类特有的方法将不能调用。

 

3.多态调用注意事项

 

  成员变量编译看父类中是否存在,不存在编译失败

  成员变量运行父类中的变量

  成员方法编译看父类中是否存在,不存在编译失败

  成员方法运行子类重写的方法

 

4.多态的好处和弊端

 

多态的存在意义(优点)为:配合继承与方法重写提高了代码的复用性与扩展性,如果没有方法重写,则多态同样没有意义。

多态的弊端: 不能调用子类的特有方法。

 

5.向上转型与向下转型

向上转型:当有子类对象赋值给一个父类引用时,便是向上转型,多态本身就是向上转型的过程。

向上转型的使用格式

1 父类类型  变量名 = new 子类类型();
2 如:Animal  p = new Cat();

向下转型:一个已经向上转型的子类对象可以使用强制类型转换的格式,将父类引用转为子类引用,这个过程是向下转型。如果是直接创建父类对象,是无法向下转型的!

向下转型的使用格式

1 子类类型 变量名 = (子类类型) 父类类型的变量;
2 如:Cat c = (Cat) a;  //变量p 实际上指向Cat对象

 instanceof关键字

判断对象是否可以向下转型 返回值为boolean

1 boolean b = 引用变量 instanceof 类;
2 if(a instanceof Dog){
3    Dog d = (Dog)a;
4 }

 

五.static关键字

1.static概念

static它是静态修饰符,一般用来修饰类中的成员。

2.static 的特点

 

static是静态修饰符,一般修饰成员。被static修饰的成员属于类,不属于单个对象。

static修饰的成员被多个对象共享。

static修饰的成员属于类,但是会影响每一个对象。

被static修饰的成员又叫类成员,不叫对象的成员。

 

3.static修饰成员的使用

 

被static修饰的成员可以并且建议通过类名直接访问。也可以通过某个对象访到属于类的静态成员,原因即多个对象均属于一个类,共享使用同一个静态成员。

格式:

类名.静态成员变量名

类名.静态成员方法名(参数)

 

对象名.静态成员变量名           ------不建议,出现警告

对象名.静态成员方法名(参数)    ------不建议,出现警告

 

 1 class Demo {
 2     //非静态成员变量
 3     public int num1 = 100;
 4 //静态成员变量
 5 public static int num2 = 100;
 6 
 7     //非静态方法
 8     public void method(){
 9         System.out.println("静态方法");
10     }
11 //静态方法
12     public static void method(){
13         System.out.println("静态方法");
14     }
15 
16 }
17 class Test {
18     public static void main(String[] args) {
19         System.out.println(Demo.num);
20         Demo.method();
21     }
22 }

 

4.静态代码快

静态代码块是定义在成员位置,使用static修饰的代码块。

特点:

在同一个类中,它优先于主方法执行、优先于构造代码块执行,当以任意形式第一次使用到该类时执行。

该类不管创建多少对象,静态代码块只执行一次。

可用于给静态变量赋值,用来给类进行初始化。//数据库JDBC

 

1 public class Person {
2     private String name;
3     private int age;
4  //静态代码块
5     static{
6         System.out.println("静态代码块执行了");
7     }

 

六.final关键字

1.final关键字的概念

继承的出现提高了代码的复用性,并方便开发。但随之也有问题,有些类在描述完之后,不想被继承,或者有些类中的部分方法功能是固定的,不想让子类重写。这个时候就要使用到final关键字。

2.final关键字的特点

  •   final修饰类不可以被继承,但是可以继承其他类。

  •   final修饰的方法不可以被覆盖,但父类中没有被final修饰方法,子类覆盖后可以加final。

  •   final修饰的变量称为常量,这些变量只能赋值一次。

  •   引用类型的变量值为对象地址值,地址值不能更改,但是地址内的对象属性值可以修改。

  •   修饰成员变量,需要在创建对象前赋值,否则报错。

  •   也可以成员变量不赋值,但是构造方法必须赋值

七.四种访问权限修饰符

  public protected default private
同一类中 可调用 可调用 可调用 可调用
同一包中 可调用 可调用 可调用  
不同包中 可调用 可调用    
不同包中的无关类 可调用      
  •   要想仅能在本类中访问使用private修饰;

  •   要想本包中的类都可以访问不加修饰符即可;

  •   要想本包中的类与其他包中的子类可以访问使用protected修饰

  •   要想所有包中的所有类都可以访问使用public修饰。

  •   如果类用public修饰,则类名必须与文件名相同。一个文件中只能有一个public修饰的类

 

八.内部类

1.内部类的概念

将类写在其他类的内部,可以写在其他类的成员位置和局部位置,这时写在其他类内部的类就称为内部类。其他类也称为外部类。

访问方式

 

外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

 

2.匿名内部类

内部类是为了应对更为复杂的类间关系。

最常用到的内部类就是匿名内部类,它是局部内部类的一种。

定义的匿名内部类有两个含义:

  • 临时定义某一指定类型的子类。
  • 定义后即刻创建刚刚定义的这个子类的对象。

格式

 

1 new 父类或接口(){
2     //进行方法重写
3 };

 

 

九.Object类

 

Object类是Java语言中的根类,即所有类的父类。它中描述的所有方法子类都可以使用。所有类在创建对象的时候,最终找的父类就是Object。

两个常用方法1.equals 2.toString

开发中经常重写这两个方法,让这两个方法更符合开发时的使用。

1. equals(Object);方法,用于比较两个对象是否相同,它其实就是比较两个对象的地址值是否相同。

2.toString();方法,就是返回该对象的字符串表示,其字符串内容是对象的类型[email protected]+内存地址值。

 

十.异常

1.异常的概念

 

在Java等面向对象的编程语言中,异常本身是一个类,产生异常就是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理。

 

2.异常的分类

异常和错误的根类是Throwable,异常类皆继承java.lang.Throwable;

旗下有两个子类,Error与Exception。

  • 严重错误Error:无法通过处理的错误。
  • 编译时异常Exception,编译时无法通过。
  • 运行时异常RuntimeException,是Excption的子类,运行时可能会报错,可以不处理。

3.异常的基本操作

  • 创建异常对象
  • 对异常的基本操作有两种
  1. 抛出异常
  2. 捕获异常(使用try/catch做分支处理)

 

声明抛出处理,出现异常后不处理,声明抛出给调用者处理。

方法声明上加throws  异常类名

 

注意:异常处理,指处理的一种可能性,即有了异常处理的代码,不一定会产生异常。如果没有产生异常,则代码正常执行,如果产生了异常,则中断当前执行代码,执行异常处理代码。

抛出异常 throw(动词,表示抛出异常的动作)

使用格式:

throw new 异常类名(参数);

声明异常 throws(将异常标识出来,报告给调用者我这个方法可能会出现这种异常)

声明异常格式:

修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2… {   }

 

4.捕获异常 try…catch…finally

 

捕获:Java中对异常有针对性的语句进行捕获,可以对出现的异常进行指定方式的处理

捕获异常格式:

 1 try {
 2 
 3     //需要被检测的语句。
 4 
 5 }
 6 
 7 catch(异常类 变量) { //参数。
 8 
 9     //异常的处理语句。
10 
11 }
12 
13 finally {
14 
15     //一定会被执行的语句。
16 
17 }

try:该代码块中编写可能产生异常的代码。

catch:用来进行某种异常的捕获,实现对捕获到的异常进行处理。

finally有一些特定的代码无论异常是否发生,都需要执行。另外,因为异常会引发程序跳转,导致有些语句执行不到。而finally就是解决这个问题的,在finally代码块中存放的代码都是一定会被执行的。

 

5.异常的注意事项

 

  • 多异常处理

     捕获处理:

  1. 多个异常分别处理
  2. 多个异常一次捕获多次处理
  3. 多个异常一次捕获一次处理

     声明抛出异常:

    声明上使用,一次声明多个异常  

 

  • 运行时异常被抛出可以不处理。即不捕获也不声明抛出
  • 如果父类方法抛出了多个异常,子类覆盖父类方法时,只能抛出相同的异常或者是他的子集
  • 父类方法没有抛出异常,子类覆盖父类该方法时也不可抛出异常。此时子类产生该异常,只能捕获处理,不能声明抛出[多线程会用到这个]
  • 当多异常处理时,捕获处理,前边的类不能是后边类的父类
  • 在try/catch后可以追加finally代码块,其中的代码一定会被执行,通常用于资源回收。

 

 十一.常用API

1.Date类

类 Date 表示特定的瞬间,精确到毫秒。

继续查阅Date类的描述,发现Date拥有多个构造函数,只是部分已经过时,但是其中有未过时的构造函数可以把毫秒值转成日期对象。

  • Date();   获取一个当前日期对象
  • Date(long date); 获取一个距离标准基准时间 date毫秒数的日期对象。
  • Date方法默认调用了toString对象
  • long getTime(返回一个自标准基准时间以来的此Date对象表示的毫秒数);

2.DateFormat

DateFormat 是日期/时间格式化子类的抽象类,它以与语言无关的方式格式化并解析日期或时间。日期/时间格式化子类(如 SimpleDateFormat)允许进行格式化(也就是日期 -> 文本)、解析(文本-> 日期)和标准化。

我们通过这个类可以帮我们完成日期和文本之间的转换。

 

DateFormat类的作用:即可以将一个Date对象转换为一个符合指定格式的字符串,也可以将一个符合指定格式的字符串转为一个Date对象。

1 代码演示:
2 //创建日期格式化对象,在获取格式化对象时可以指定风格
3 DateFormat df= new SimpleDateFormat("yyyy-MM-dd");//对日期进行格式化
4 Date date = new Date(1607616000000L);
5 String str_time = df.format(date);
6 System.out.println(str_time);//2020年12月11日

 

 

指定格式的具体规则我们可参照SimpleDateFormat类的说明,这里做简单介绍,规则是在一个字符串中,会将以下字母替换成对应时间组成部分,剩余内容原样输出:

 

  • 当出现y时,会将y替换成年
  • 当出现M时,会将M替换成月
  • 当出现d时,会将d替换成日
  • 当出现H时,会将H替换成时
  • 当出现m时,会将m替换成分
  • 当出现s时,会将s替换成秒

DateFormat的两个常用方法

1.format(Date date);将一个Date格式化为日期/时间字符串。

2.parse(String source); 从给定字符串的开始解析文本,以生成一个日期。

 

format方法,用来将Date对象转换成String

 

parse方法,用来将String转换成Date(转换时,该String要符合指定格式,否则不能转换)。

2.calendar类

Calendar是日历类,在Date后出现,替换掉了许多Date的方法。该类将所有可能用到的时间信息封装为静态成员变量,方便获取。

Calendar为抽象类,由于语言敏感性,Calendar类在创建对象时并非直接创建,而是通过静态方法创建,将语言敏感内容处理好,再返回子类对象。

Calendar类静态方法

getInstance();  使用一个默认时区和语言环境获得一个日历

Calendar c = Calendar.getInstance();  //返回当前日历对象

Calendar类常用方法

  1. add(int field , int mount);  为给定的日历字段添加或减去指定的时间量
  2. get(int field); 返回给定日历字段的值
  3. getInstance(); 使用默认时区和语言环境获得一个日历
  4. getTime(); 返回一个表示此Calendar时间值的Date对象
  5. set(int field, int mount);将给定的日历字段设置为给定值

  YEAR 年

  MONTH 月,从0开始算起,最大11;0代表1月,11代表12月。

  DATE 天

  HOUR 时

  MINUTE分

  SECOND秒

注意事项

西方星期的开始为周日,中国为周一。

在Calendar类中,月份的表示是以0-11代表1-12月。

日期是有大小关系的,时间靠后,时间越大。

3.System类

 

在API中System类介绍的比较简单,我们给出定义,System中代表程序所在系统,提供了对应的一些系统属性信息,和系统操作。

查看文档System类不能手动创建对象,因为构造方法被private修饰,阻止外界创建对象。System类中的都是static方法,类名访问即可。在JDK中,有许多这样的类。

 

常用方法

static long currentTimeMillis(); 返回以毫秒值为单位的当前时间。

static void exit(int status); 终止当前正在运行的Java虚拟机(0记为正常状态,其他为异常状态)

static void gc(); 运行垃圾回收(并没有什么卵用)

static String getProperty(String key);  获取指定键的系统属性

4.Math类

 

Math 类是包含用于执行基本数学运算的方法的数学工具类,如初等指数、对数、平方根和三角函数。

 

类似这样的工具类,其所有方法均为静态方法,并且一般不会创建对象。如System类

static double abs(double a); 返回double值的绝对值

static double ceil(double a); 向上取整

static double floor(double a);向下取整

static double max(double a , double b); 返回较大值

static double min(double a ,double b); 返回较小值

static double pow(double a , double b); 返回 a的b次幂的值

static double random(); 返回一个随机的大于等于0.0且小于1.0的double 值

static long round(double a ); 四舍五入

5.基本类型包装类

java将基本数据类型值封装成了对象。

 

其中需要注意int对应的是Integer,char对应的Character,其他6个都是基本类型首字母大写即可。

 

parseXXX(String s);其中XXX表示基本类型,参数为可以转成基本类型的字符串,如果字符串无法转成基本类型,将会发生数字转换的问题NumberFormatException

在需要的情况下,基本类型与包装类型可以通用。有些时候我们必须使用引用数据类型时,可以传入基本数据类型。

 

自动拆箱:对象转成基本数值

自动装箱:基本数值转成对象

6.正则表达式

正则表达式(英语:Regular Expression,在代码中常简写为regex)。

正则表达式是一个字符串,使用单个字符串来描述、用来定义匹配规则,匹配一系列符合某个句法规则的字符串。在开发中,正则表达式通常被用来检索、替换那些符合某个规则的文本。

常用方法

1.matches(String regex); 判断字符串是否匹配给定的规则

2.split(String regex);根据给定正则表达式的匹配规则,拆分此字符串

十一.集合

 

数组的长度是固定的。集合的长度是可变的。

数组中存储的是同一类型的元素,可以存储基本数据类型值。

集合存储的都是对象。而且对象的类型可以不一致。

 

Collection接口是集合中的顶层接口,它中定义的所有功能子类都可以使用。查阅API中描述的Collection接口。Collection 层次结构 中的根接口。Collection 用来存储一组对象,这些对象也称为 collection 的元素。一些 collection 允许有重复的元素,而另一些则不允许。

 

1.Collection接口的基本方法

 

boolean add(E e); 添加对象,并判断是否删除成功 (増)

void clear(); 删除集合中的所有成员 (删)

boolean contains(Object o);  判断集合中是否包含o(查)

boolean remove(Object o);  删除对象,并判断是否删除成功 (删)

int size(); 返回collection的元素数(查)

Object[] toArray(); 返回包含此collection中所有元素的数组 

 

 

2.Iterator 迭代器

 

java中提供了很多个集合,它们在存储元素时,采用的存储方式不同。我们要取出这些集合中的元素,可通过一种通用的获取方式来完成。

 

Collection集合元素的通用获取方式:在取元素之前先要判断集合中有没有元素,如果有,就把这个元素取出来,继续在判断,如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。

 

常用方法

boolean hasNext(); 如果仍有元素可以迭代,则返回true,说明可以迭代。

E next(); 返回迭代的下一个元素,并把指针向后移动一位。

 

 1 //1,创建集合对象。
 2 Collection<String> coll = new ArrayList<String>();
 3 coll.add("abc1");
 4 coll.add("abc2");
 5 coll.add("abc3");
 6 coll.add("abc4");
 7 
 8 //2.获取容器的迭代器对象。通过iterator方法。
 9 Iterator it = coll.iterator();
10 
11 //3,使用具体的迭代器对象获取集合中的元素。参阅迭代器的方法
12 while(it.hasNext()){
13     System.out.println(it.next());
14 }
15 
16 /* 
17 迭代器for循环的形式的使用
18 for (Iterator it = coll.iterator(); it.hasNext();  ) {
19     System.out.println(it.next());
20 }
21 */

 

迭代的常规用法中我们要尽量避免在迭代过程中为集合添加/删除数据。否则会报错,原因是Java抛出了并发修改异常。        

迭代过程中并发修改异常的原因为:

迭代器中”记忆”的集合长度与集合中实际长度不同,而导致出现索引与实际元素不符甚至无限循环的情况发生。

 

3.增强for循环

 

增强for循环是JDK1.5以后出来的一个高级for循环,专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器,所以在遍历的过程中,不能对集合中的元素进行增删操作。

 

格式:

for(元素的数据类型  变量 : Collection集合or数组){

 

}

它用于遍历Collection和数组。通常只进行遍历元素,不要在遍历的过程中对集合元素进行增删操作。

增强for循环和老式的for循环有什么区别?

注意:新for循环必须有被遍历的目标。目标只能是Collection或者是数组。

建议:遍历数组时,如果仅为遍历,可以使用增强for如果要对数组的元素进行 操作,使用老式for循环可以通过角标操作。

十二.泛型

 

泛型:就是一种不确定的类型(JDK1.5的一个新特性)

 

基本体现: <E>这就是泛型 可以是任意类型

  • 泛型用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数传递。
  • 泛型是数据类型的一部分,将类名与泛型合并一起看做数据类型。
  • 泛型的定义:定义泛型可以在类中预支地使用未知的类型。
  • 泛型的使用:一般在创建对象时,将未知的类型确定具体的类型。当没有指定泛型时,默认类型为Object类型。

1.使用泛型的好处

  • 将运行时期的ClassCastException,转移到了编译时期变成了编译失败。
  • 避免了类型强转的麻烦。

2.含有泛型的类:泛型类

定义格式:修饰符 class 类名<代表泛型的变量> {  }

使用格式:创建对象时,确定泛型的类型

3.含有泛型的方法

定义格式:修饰符 <代表泛型的变量> 返回值类型 方法名(参数){  }

使用格式:调用方法时,确定泛型的类型

4.含有泛型的接口

定义格式:修饰符 interface接口名<代表泛型的变量> {  }

使用格式:

1、实现接口时,确定泛型的类型

2、实现接口,不指定泛型的类型,直到创建对象时,确定泛型的类型

5.泛型通配符

当使用泛型类或者接口时,传递的数据中,泛型类型不确定,可以通过通配符<?>表示。但是一旦使用泛型的通配符后,只能使用Object类中的共性方法,集合中元素自身方法无法使用。

 

定义:(查看ArrayList的构造方法或者addAll方法)无法在类中使用

            使用:调用方法时可以给予任意类型。参照Arraylist的构造方法或者addAll方法

? extends E代表只要是E类型的子类即可

? super E代表只要是E类型的父类即可

 

以上是关于Java学习周记week03的主要内容,如果未能解决你的问题,请参考以下文章

Java学习周记week02

考研周记-week14

考研周记-week12

考研周记-week4

周记(第三周)

第五周周记