当前位置: 首页 > article >正文

背诵--2

DAY01 面向对象回顾、继承、抽象类

学习目标

能够写出类的继承格式
	public class 子类 extends 父类{}
	public class Cat extends Animal{}
能够说出继承的特点
	子类继承父类,就会自动拥有父类非私有的成员
能够说出子类调用父类的成员特点
	1.子类有使用子类自己的
	2.子类没有使用,继承自父类的
	3.子类父类都没有编译报错
能够说出方法重写的概念
	发生在两个类之间
	子类出现了和父类一模一样(返回值类型,方法名,参数列表,修饰符子类大于等于父类)的方法,叫方法重写(Override)
能够说出this可以解决的问题
	1.this.变量名:代表本类的成员变量
	2.this.方法名称():代表本类的成员方法
	3.this(),this(参数):代表调用本类其他的构造方法
能够说出super可以解决的问题
	1.super.变量名:代表父类的成员变量
	2.super.方法名称():代表父类的成员方法
	3.super(),super(参数):代表调用父类的构造方法
描述抽象方法的概念
	没有方法体,被abstract修饰的方法
写出抽象类的格式
	public abstract class 类名{};
写出抽象方法的格式
	权限修饰符 abstract 返回值类型 方法名(参数);
	public abstract void aaa();
	public abstract int bbb();
	public abstract int ccc(String s);
能够说出父类抽象方法的存在意义
	在抽象类中定义类抽象方法,那么子类就必须重写这个抽象方法
	公司中所有的员工都必须工作
	作为模版:让子类强制重写抽象方法,不同的子类添加不同的方法体

this关键字


/*
    this关键字:
        代表本类对象的引用==>根据类创建的对象
        哪个对象调用的方法,方法中的this就是哪个对象

    this关键字作用:当局部变量和成员变量重名时,使用this关键字可以区分局部变量和成员变量
        this.变量名==>成员变量
 */

对象的内存图

请添加图片描述

匿名对象

package com.itheima.demo03Object;

import java.util.ArrayList;

/*
    匿名对象:
        创建对象时,只有创建对象的语句,没有把对象赋值给某个变量,这个对象叫匿名对象
        没有名字的对象
    特点:
        只能使用一次,使用完毕会被JVM在空闲的时候进行垃圾回收
    好处:
        可以节约内存,可以提高程序的效率
    作用:
        一般可以作为方法的参数和返回值使用
 */
public class Demo01Animal {
    public static void main(String[] args) {
        //创建一个有名字的对象:可以重复使用
        Animal a1 = new Animal("Tom");
        a1.eat();
        a1.eat();

        //创建一个匿名对象:只能使用一次
        new Animal("Jerry").eat();
        //如果想要在使用匿名对象,需要重新创建
        new Animal("熊大").eat();
        System.out.println("---------------------------");
        //调用show方法,创建Animal对象为变量a2赋值
        show(a1);
        //如果方法的参数传递的对象只使用一次,就可以使用匿名对象
        show(new Animal("熊二"));
        System.out.println("----------------------------");
        //调用getAnimal方法
        //Animal a4 = getAnimal();==> new Animal("光头强");
        Animal a4 = getAnimal();
        a4.eat();
        System.out.println("----------------------------");
        ArrayList<Animal> list = new ArrayList<>();
        list.add(a1);
        //对象只使用一次,就可以使用匿名对象
        list.add(new Animal("加菲猫"));
    }

    /*
        定义一个方法,方法的参数使用Animal类型
        Animal a2 = a1 = new Animal("Tom");
        Animal a2 = new Animal("熊二")
     */
    public static void show(Animal a2){
        a2.eat();
    }

    /*
        定义一个方法,方法的返回值类型使用Animal
            方法的返回值类型是Animal,就必须在方法中创建一个Animal对象返回
            方法的返回值类型是int,就必须在方法中返回一个整数
            ...
     */
    public static Animal getAnimal(){
        //Animal a3 = new Animal("光头强");
        //return a3;
        //对象只使用一次,就可以使用匿名对象
        return new Animal("光头强");
    }
}

继承

继承的概念:子类继承父类,子类就会自动拥有父类非私有的成员变量和成员方法。
继承的特点:
	子类继承父类,子类就会自动拥有父类非私有的成员变量和成员方法
	在子类中可以定义子类特有的成员
继承的注意事项:
	1.构造方法是不能继承的,构造方法是本类创建对象使用的
	2.父类私有成员子类是不能继承的
继承后的特点—成员变量:
	1.子类有使用子类自己的成员变量
	2.子类没有使用子类继承自父类的成员变量
	3.子类和父类都没有,编译报错
继承后的特点—成员方法:
	1.子类有使用子类自己的成员方法
	2.子类没有使用子类继承自父类的成员方法
	3.子类和父类都没有,编译报错

方法重写

/*
    方法重写:发生在两个类之间,在子类中出现了和父类一模一样的方法,叫方法重写(Override)
        一模一样:
            方法名一样
            参数列表一样
            返回值类型一样
            修饰符一样(子类的修饰符权限大于等于父类的修饰符)
        注解:
            @Override:检查方法是否为重写的方法
   ------------------------------------------------------------
   方法重载:发生在一个类中,在一个类中出现了方法名相同,但是参数列表不同的方法,叫方法重载(Overload)
 */

this和super

    /*
        继承后的特点—构造方法
        在子类构造方法的第一行,有一个默认的super();
        super();作用就是调用父类的空参数构造方法
        子类继承父类,子类想要使用继承自父类的成员,就必须把父类加载到内存中,调用父类的构造方法创建父类对象
        父类进入到内存中,子类才可以使用父类的成员
     */

请添加图片描述
请添加图片描述

/*
    this关键字:本类对象的引用(根据Cat创建的对象)
        this.成员变量:本类的成员变量
        this.成员方法(参数):本类的成员方法
    super关键字:父类对象的引用(根据Animal创建的对象)
        super.成员变量:父类的成员变量
        super.成员方法(参数):父类的成员方法
 */
 /*
    this关键字:可以调用本类其他的构造方法
    格式:
        this();调用空参数构造方法
        this(参数);调用带参数构造方法
    注意:
        1.this();|this(参数);调用构造方法必须写在构造方法中的第一行,创建对象必须优先执行
        2.构造方法不能相互调用(不能你调用我,我在调用你-->死循环)
 */
 /*
    super关键字:调用父类的构造方法
    格式:
        super();调用父类的空参数构造方法
        super(参数);调用父类带参数构造方法
    注意:
        1.在子类的构造方法中没有写super();有一个默认的super();用于调用父类的空参数构造方法
        2.super();|super(参数);必须写在子类构造方法有效代码的第一行,构造方法必须优先执行
        3.在子类的构造方法中this和super不能同时出现,都必须写在有效代码第一行
 */

DAY02 final关键字、static关键字、接口

学习目标

描述final修饰的类的特点
	//是一个最终类不能被继承,是一个太监类
描述final修饰的方法的特点
	//是一个最终方法,可以被继承使用,但是不能被重写
描述final修饰的变量的特点
	//是一个常量,值不能改变
	局部变量:定义在方法中的变量
		基本数据类型:值不能改变
		引用数据类型(数组,对象,集合...):地址值不能改变
	成员变量:定义在成员位置,类中方法外
		保证在创建对象前赋值
			1.可以定义变量的时候直接赋值
			2.可以使用构造方法给变量赋值
能够掌握static关键字修饰的变量调用方式
	类名.静态成员变量
	public class Person{
		static int a = 10;
	}
	Person.a;
能够掌握static关键字修饰的方法调用方式
	类名.静态成员方法(参数);
	public class Person{
		public static void show(int a){}
	}
	Person.show(10);
能够写出接口的定义格式
	public interface 接口名{
		抽象方法 public abstract 返回值类型 方法名(参数);
		默认方法 public default 返回值类型 方法名(参数){方法体}
		静态方法 public static 返回值类型 方法名(参数){方法体}
	}
能够写出接口的实现格式
	public class 实现类 implements 接口{}
能够说出接口中的成员特点
	变量:接口中的变量都是常量,有固定的修饰符 public static final int AAA = 10;
	方法:抽象方法(需实现类重写) 默认方法(实现类可以选择性重写) 静态方法(不能重写,使用接口名直接调用)
	接口中没有构造方法,不能创建对象

final关键字

/*
    final修饰的类:是一个最终类,不能被继承;其他的使用方式不变(继承其他的类,创建对象使用...)
    简单记:太监类
*/
/*
    final修饰的方法:是一个最终方法,可以被继承使用,但是不能被重写
 */
 /*
    final修饰的变量:是一个常量,值不能改变
    局部变量:定义在方法中的变量(语句中for)
    final修饰符是局部变量唯一的修饰符
    引用数据类型(数组,类,集合...):地址值不能改变
    对象中的内容是可以改变的(成员变量的值,数组中的元素,集合中的元素...)
 */
 /*
    final修饰的成员变量:是一个常量,值不能改变
    特点:特殊记忆
        final修饰的成员变量必须在创建对象前赋值(规定)
    注意:
        1.成员变量的默认值(String=>null,int==>0,doble=>0.0,boolean==>false),不是final修饰的成员变量的值,必须赋一个具体值
        2.赋值的方式:
            a.直接赋值:定义变量,直接给变量赋值
            b.使用构造方法赋值,构造方法是创建对象前执行
            无论哪种赋值方式,只能赋值一次
        3.常量的命名规则:一般都使用大写字母
            final int  AAA_BBB_CCC = 10;
 */
public class Student {
    //final int a;//Variable 'a' might not have been initialized

    //a.直接赋值:定义变量,直接给变量赋值
    final int b = 10;

    final int c;

    final String d = null;

    //b.使用构造方法赋值,构造方法是创建对象前执行
    public Student() {
        c = 20;
        //b = 100;//Cannot assign a value to final variable 'b' 无论哪种赋值方式,只能赋值一次
    }

    public Student(int e){
        c=e;
    }
}

static关键字

请添加图片描述
请添加图片描述

接口

接口:是引用数据类型的一种,是功能的集合(接口中定义的都是方法)
    接口中不能定义变量,可以定义常量(很少使用)
定义接口使用的也是.java文件;编译生成的也是.class文件
定义接口使用关键字interface
定义格式:
	修饰符 interface 接口名{
        抽象方法;(jdk7)重点
        默认方法;(jdk8)
        静态方法;(jdk8)
    }

/*
    接口的多实现:类可以同时实现多个接口
    格式:
        public class 实现类 implements 接口1,接口2,接口3....接口n{
            重写所有接口中的抽象方法
        }
     注意:
        接口中含有抽象方法,实现类需要重写所有接口的抽象方法
        如果接口中有同名的抽象方法,实现类只重写一个就可以了
        不会产生不确定性,抽象方法没有方法体
 */
 
/*
    接口的多实现:类实现含有默认方法的多个接口
    格式:
        public class 实现类 implements 接口1,接口2,接口3....接口n{
        }
    注意:
        1.如果接口中的默认方法不重复,实现类可以选择重写或者不重写默认方法
            重写:使用实现类重写的
            不重写:使用继承自接口的
        2.如果多个接口中默认方法有重复的,实现类必须重写这个重复的默认方法
            有不确定性,实现类不知道使用继承自哪个接口的默认方法,重写之后使用自己的
 */
/*
    接口的多实现:实现类实现含有静态方法的多个接口
    格式:
        public class 实现类 implements 接口1,接口2,接口3....接口n{
        }
    注意:
        1.实现类实现含有静态方法的接口,没有意义;静态方法实现类不能继承,也不能重写
        2.接口中静态方法有重复的,不会冲突,静态方法属于每个接口本身
 */
/*
    接口中其他成员的特点(使用)
        1.接口中是无法定义成员变量的,但是可以定义常量,常量的值不能改变
            默认使用的修饰符public static final,接口中的常量修饰符可以省略不写,默认默认也是public static final
            常量的命名规则:所有的单词都要大写,多个单词之间使用下划线连接
                AAA_BBB_CCC
                定义一些常用的常量:
                    公司的名称:"江苏省传智播客股份有限公司北京分公司"
                    公司的网址: www.itcast.cn    www.itheima.com
                    公司地址: 昌平区建材城西路金燕龙办公楼一层
       2.接口中,没有构造方法,不能创建对象
       3.接口中,没有静态代码块(讲代码块的时候在说)
 */ 

DAY03 多态、内部类、权限修饰符、代码块

学习目标

能够说出多态的前提
	//有子父类继承关系|有类和接口的实现关系
能够写出多态的格式
	//父类的类型 变量名 = new 子类对象();
	Animal a = new Cat();
	Animal a = new Dog();
	//接口的类型 变量名 = new 实现类对象();
	Fly f = new MaQue();
能够理解多态向上转型和向下转型
	//向上转型:多态本身就是向上转型
		格式:
			父类的类型 变量名 = new 子类对象();
			接口的类型 变量名 = new 实现类对象();
			Animal a = new Cat();
			a = new Dog();
		好处:
			扩展性强,可以赋值不同的子类对象,调用不同子类重写的方法
		弊端:
			无法使用子类特有的成员变量和成员方法
	//向下转型:前提必须是多态,可以把父类的类型强制转换为子类类型
		格式:
			子类类型 变量名 = (子类类型)父类变量名;
			Cat c = (Cat)a;
			c.catchMouse();
		好处:
			可以使用子类特有的内容
能够说出内部类概念
	//把类定义在其他类的内部
		成员内部类:类定义在其他类的成员位置
		局部内部类:类定义在其他类的方法中
		注意:局部位置唯一可以使用的修饰符就是final
能够理解匿名内部类的编写格式(new 爹(亲爹父类,干爹接口))
	作用:简化代码
		把子类继承父类,重写父类的方法,创建子类对象合成一步完成;
		把实现类实现接口,重写接口中的方法,创建实现类对象合成一步完成;
	格式:
		new 父类|接口(){
			重写父类|接口中方法;
		};
		new Animal(){
			public void eat(){}
			public void sleep(){}
		}.eat();
		new Fly(){
			public void fly(){}
		}.fly();
能够说出每种权限修饰符的作用
	private:只能在本类中使用
	默认(不写):既能在本类中使用,又能在本包的其他类中使用
	protected:既能在本类中使用,又能在本包的其他类中使用,还能在不同包的子类中使用
	public:本项目中的任意包,任意的类中都可以使用
	需要记住(重点):
		1.privare使用:定义成员变量,需要私有(封装)
		2.public使用:定义成员方法,定义构造方法,定义类
代码块:
	静态代码块:只执行一次,优先执行

多态

请添加图片描述
请添加图片描述

/*
    多态的转型:
        1.向上转型:多态本身就是向上转型,把子类对象赋值给父类的变量
            格式:
                父类类型 变量名 = new 子类对象():
            好处:
                扩展性强,可以赋值不同的子类对象,而调用不同子类重写后的方法
            --------------------------------------------------------------
            int a = 10;
            double d = a;
        2.向下转型:把父类类型的变量强制转换为子类类型(强转)
            格式:
                子类类型 变量名 = (子类类型)父类变量名;
            好处:
                强制之后,多态变量变成了子类类型,就可以使用子类特有的功能
            注意:
                a.向下转型前提,必须是多态
                b.直接创建父类对象,不能向下转型
            -----------------------------------------------------------------
            double d = 5.5;
            int a = (int)d;
 */
 /*
    向下转型:有可能发生类型转换异常
    ClassCastException: com.itheima.demo02duotai.Cat cannot be cast to com.itheima.demo02duotai.Dog
    猫不能转换为狗

    instanceof关键字:判断某个对象是否属于某种数据类型
    格式:
        boolean b = 对象 instanceof 数据类型;
        对象属于对应的数据类型,返回true
        对象不属于对应的数据类型,返回false
    使用前提:
        对象根据类创建的(对象所属的类和判断的数据类型之间必须有继承或者实现关系)
 */

内部类

/*
    内部类:定义在其他类内部的类
    分类:
        成员内部类:内部类定义在其他类的成员位置(类中方法外)
        局部内部类:内部类定义在其他类的方法中
    重点:记住固定格式
    ---------------------------------------------------------------
    成员内部类:
        定义格式:
            修饰符 class 外部类{
                修饰符 class 成员内部类名{
                    内部类的成员变量
                    内部类的成员方法
                }
            }
        使用格式:通过外部类来找到内部类
            外部类名.内部类名 变量名 = new 外部类().new 内部类();
            变量名.内部类的成员变量
            变量名,内部类的成员方法();
   注意:
       1.在内部类中可以直接使用外部类的成员变量和成员方法
       2.内部类只是定义在其他类的内部,其他的使用方式不变,也可以继承其他的类,也可以实现接口
 */

注意:内部类生成的class文件含有$
请添加图片描述

/*
    局部内部类:定义在其他类的方法中
    定义格式:
        修饰符 class 外部类名{
            修饰符 返回值类型 外部类方法名(参数){
                (final)class 局部内部类名{
                    内部类的成员变量,
                    内部类的成员方法();
                }
            }
        }
    使用格式:局部内部类的使用范围就是在方法中有效
        使用方式就是在方法中定义完局部内部类之后,直接创建局部内部类对象使用
 */
public class Outer {
    //定义一个外部类的成员方法
    public void show01(){
        //定义局部内部类(局部变量唯一可以使用的修饰符final 面试)
        final class Inner{
            //定义局部内部类的成员变量
            int a = 10;
            //定义局部内部类的成员方法
            public void inner(){
                System.out.println("局部内部类Inner的成员方法inner!");
            }
        }

        //定义完局部内部类之后,直接创建局部内部类对象使用
        Inner in = new Inner();
        System.out.println(in.a);
        in.inner();

        //final int aa = 10;
        //System.out.println(aa);

    }

    //定义一个外部类的成员方法
    public void show02(){
        //定义局部内部类(局部变量唯一可以使用的修饰符final 面试)
        final class Inner{
            //定义局部内部类的成员变量
            int a = 10;
            //定义局部内部类的成员方法
            public void inner(){
                System.out.println("局部内部类Inner的成员方法inner!");
            }
        }

        //定义完局部内部类之后,直接创建局部内部类对象使用
        Inner in = new Inner();
        System.out.println(in.a);
        in.inner();

        //final int aa = 10;
        //System.out.println(aa);

    }
}

注意:局部内部类生产的class含有$(1,2,3指的是外部类中第1个,第2个…方法)
请添加图片描述

/*
    匿名内部类(重点):
        匿名:创建内部类,不像Cat.Dog有类名,没有具体的类名
        内部类:是一个局部内部类(写在方法中)
    作用:简化代码
        把子类继承父类,重写父类的方法,创建子类对象合成一步完成
        把实现类实现接口,重写接口中的方法,创建实现类对象合成一步完成
    格式:
        new 父类|接口(){
            重写父类|接口中的方法;
        };
     ------------------------------------------------
     new Animal(){
        @Override
        public void eat() {
            System.out.println("动物在吃饭");
        }
        @Override
        public void sleep() {
            System.out.println("动物在睡觉!");
        }
    };
    以上一堆代码就是一个创建子类对象的过程,相当于new Cat();
 */

权限修饰符

publicprotecteddefault(空的)private
同一类中
同一包中(子类与无关类)
不同包的子类
不同包中的无关类

代码块

public class Student {
    private String name;
    private int age;
    private static String sex;

    /*
        2.构造代码块:写在成员位置(类中方法外)的代码块
        特点:
            优先于构造方法执行,每创建一次对象,都会执行一次
        作用:
            1.可以给成员变量赋初始化值
            2.可以把每个构造方法中的共性内容提取出来,写在构造代码块中,可以提高代码复用性
                需求:无论使用空参数|带参数构造方法创建对象,都先打印10次HelloWorld
     */
    {
        //1.可以给成员变量赋初始化值
        name = "张三";
        age = 18;
        System.out.println("构造代码块!");
        //2.可以把每个构造方法中的共性内容提取出来,写在构造代码块中
        /*for (int i = 1; i <=10 ; i++) {
            System.out.println("HelloWorld"+i);
        }*/
    }

    /*
        3.静态代码块:写在成员位置(类中方法外)被static修饰的代码块
        特点:
            static修饰的成员属于类,不属于某一个对象,被所有的对象所共享
            所以我们无论创建多少次对象,静态代码块只执行一次
            静态优先于非静态加载到内存中,优先于构造代码块和构造方法执行
        作用:
            1.可以给静态的成员变量赋初始化值
            2.在项目启动的时候,可以做一些初始化的设计(只执行一次 数据库)
     */
    static {
        sex = "男";
        System.out.println("静态代码块!");
    }

    public Student() {
        /*for (int i = 1; i <=10 ; i++) {
            System.out.println("HelloWorld"+i);
        }*/
        System.out.println("Student类的空参数构造方法!");
    }

    public Student(String name, int age) {
        /*for (int i = 1; i <=10 ; i++) {
            System.out.println("HelloWorld"+i);
        }*/
        this.name = name;
        this.age = age;
        System.out.println("Student类的带参数构造方法!");
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public static String getSex() {
        return sex;
    }

    public static void setSex(String sex) {
        Student.sex = sex;
    }
}     
/*
    代码块:被{ }包裹起来的代码叫代码块
        1.局部代码块:写在方法中的代码块
        2.构造代码块:写在成员位置(类中方法外)的代码块
        3.静态代码块:写在成员位置(类中方法外)被static修饰的代码块
 */
public class Demo01 {
    public static void main(String[] args) {
        /*
            1.局部代码块:写在方法中的代码块
            作用:修改变量的作用域,提高程序的效率
            变量的作用域:在变量所在的{ }的范围内有效,出了作用域,就会被垃圾回收
         */
        {
            int a = 10;
            //System.out.println(a);
        }

        //System.out.println(a);//Cannot resolve symbol 'a'

        //for (int i = 0; i < 10; i++) {
        //    System.out.println(i);
        //}
        //System.out.println(i);//Cannot resolve symbol 'i'

        Student s1 = new Student();
        System.out.println(s1.getName()+"\t"+s1.getAge()+"\t"+s1.getSex());
        Student s2 = new Student("柳岩",18);
        System.out.println(s2.getName()+"\t"+s2.getAge()+"\t"+s1.getSex());
    }
}

DAY04 Object、Date类、DateFormat类、Calendar类、Math类、System类

学习目标

能够说出Object类的特点
	是所有类的祖宗类,任意的一个类都直接或者间接的继承了Object,都可以使用Object类中的方法
	Animal extends Object:直接继承
	Cat extends Animal:间接继承
能够重写Object类的toString方法
	alt+insert,选择toString
能够重写Object类的equals方法
	alt+insert,选择equals and hashCode
能够使用日期类输出当前日期
	import java.util.Date;
	Date date = new Date();
	sout(date);//Mon Apr 27 15:55:03 CST 2020
能够使用将日期格式化为字符串的方法
	//1.创建SimpleDateFormat对象,构造方法中传递指定的模式   
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
    //2.调用SimpleDateFormat对象中的方法format根据构造方法中传递的模式,把日期格式化为符合模式的字符串
    Date date = new Date();
    System.out.println(date);//Wed Mar 18 11:50:38 CST 2020
    String s = sdf.format(date);
    System.out.println(s);// 2020年03月18日 11时51分32秒
能够使用将字符串转换成日期的方法
	//1.创建SimpleDateFormat对象,构造方法中传递指定的模式
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
	//2.调用SimpleDateFormat对象中的方法format根据构造方法中传递的模式,把日期格式化为符合模式的字符串
	Date date =  sdf.parse("2000-12-12");
    System.out.println(date);//Tue Dec 12 00:00:00 CST 2000
能够使用Calendar类的get、set、add方法计算日期
	int get(int field) 获取给定日历字段的值。
    void set(int field, int value) 将给定的日历字段设置为给定值。
    void add(int field, int amount)  把日历字段增加|减少指定的值
能够使用Math类对某个浮点数进行四舍五入取整
	static double ceil(double a)  向上取整
    static double floor(double a)  向下取整
	static long round(double a) 四合五入 long。
能够使用System类获取当前系统毫秒值
	static long currentTimeMillis() 返回以毫秒为单位的当前时间。

Object类

  • java.lang.Object 注意:lang包中的类无需导包可以直接使用
  • Object 是类层次结构的根类(最顶层的类 祖宗类)。
  • 每个类都使用 Object 作为超类。任何一个类都直接或者间接的继承了Object类
  • 所有对象(包括数组)都实现这个Object类的方法。任何一个类都可以使用Object类中的方法
/*
    Object类中的常用方法:
        String toString() 返回该对象的字符串表示。
    Object类toString方法的底层源码:
        public String toString() {
            return getClass().getName() + "@" + Integer.toHexString(hashCode());
        }
        getClass().getName():使用反射技术获取类的全类名(包名+类名)
            com.itheima.demo01toString.Person
        "@" :字符串原样输出,分割的作用
        hashCode():Object类中的方法,可以获取对象的哈希值,哈希值是一个系统随机给出的十进制的整数 123123123
        Integer.toHexString(hashCode());把十进制的整数转换为十六进制 0-9 a-f
   组合在一起: com.itheima.demo01toString.Person@AC123(对象在堆内存中的地址值)
 */
/*
    Object类中的方法equals:
        boolean equals(Object obj) 指示其他某个对象是否与此对象“相等”。
    Object类中的equals方法的源码:
        public boolean equals(Object obj) {
            return (this == obj);
        }
        ==:比较运算符
            基本数据类型:比较的是值是否相等  10==20
            引用数据类型(数组,集合,类Person):比较的是地址值是否相等  @1ac1==@223
 */
    @Override
    public boolean equals(Object obj) {
        /*
            如果obj就是this本身,那么就没有比较在强转进行属性的比较,直接返回true,可以提高效率
         */
        if(obj == this){
            return true;
        }

        /*
            如果obj的值是null,那么直接返回false,可以提高程序的效率
         */
        if(obj==null){
            return false;
        }

        /*
            ClassCastException: java.util.Random cannot be cast to com.itheima.demo02equals.Student
            为了防止类在转换异常,强转之前使用instanceof关键字进行判断
         */
        if(obj instanceof Student){
            /*
                问题:多态==>无法使用子类特有的成员==>需要向下转型
                Object obj = s2 = new Student("韦德",38);
             */
            Student s = (Student)obj;
            //比较this(s1)和s(obj=s2)两个对象的属性name和age
            //             詹姆斯          韦德         35           38
            boolean b = this.name.equals(s.name) && this.age == s.age;
            return b;
        }
        //obj不是Student,直接返回false
        return false;
    }

native修饰的方法:说明这个方法不是java语言编写的

调用的是其他语言编写的代码或者操作系统底层的代码,看不到具体的方法

Object:
public native int hashCode();
public final native Class<?> getClass();

Objects对象的工具类(了解)

/*
    java.util.Objects类:操作对象的工具类,里边的方法都是静态的
    Objects中的方法都是防止空指针异常的
    注意:
        工具类中的方法一般都是静态的,可以通过类名直接使用
    Obejcts工具类中的equals方法
        static boolean equals​(Object a, Object b) :判断两个对象是否相等,相等返回true,不相等返回false
    底层源码:
        public static boolean equals(Object a, Object b) {
            return (a == b) || (a != null && a.equals(b));
        }
 */

Date类

java.util.Date:用于描述日期和时间的类
	类 Date 表示特定的瞬间,精确到毫秒。
	1=1000毫秒
	1= 24 × 60 × 60 = 86400= 86400*1000 = 86400000毫秒
-----------------------------------------------
时间原点:0毫秒的时间点
	19701100:00:00  英国格林威治时间(世界标准时间)
中国:东八区 时间+8个小时的时差
	19701108:00:00
把日期和时间转换为毫秒值:就是时间原点和当前时间的一个差值
	当前时间(202042711:26:33)-时间原点(19701100:00:00)=把当前时间转换为毫秒值(12312412514312)
毫秒值的作用:用于对时间进行计算
工作:计算两个时间的差值,把时间转换为毫秒值计算
	"2020年4月27日11:26:33" - "2019年3月5日12:26:33" = 没法计算
	把时间转换为毫秒值,使用毫秒值相减
	15888123123123 - 15734324324233 = 324324毫秒==>转换为时间(324324毫秒/1000/60/60/24)

请添加图片描述

DateFormat类

java.text.DateFormatpublic abstract class DateFormat extends Format
DateFormat 是日期/时间格式化子类的抽象类==> DateFormatFormat类的子类,DateFormat本身还是一个抽象类
无法直接创建对象使用
作用:
	它以与语言无关的方式格式化并解析日期或时间。
	格式化(也就是日期 -> 文本)
	解析(文本-> 日期)
DateFormat类的成员方法:
	String format(Date date) 传递指定的日期,把日期格式化为符合模式的字符串 
	Date parse(String source) 把符合模式的字符串解析为Date日期
-----------------------------------------------------------------
DateFormat本身还是一个抽象类,无法直接创建对象使用,需要使用DateFormat类的子类创建对象使用
java.text.SimpleDateFormatextends DateFormatSimpleDateFormat类构造方法
	SimpleDateFormat(String pattern) 
          用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。
   参数:
	 String pattern:传递日期和时间的模式
	 	在模式中写y代表年
        在模式中写M代表月
        在模式中写d代表日
        在模式中写H代表时
        在模式中写m代表分
        在模式中写s代表秒
        在模式中写S代表毫秒
        "yyyy-MM-dd HH:mm:ss"  "2020-04-27 11:57:03"
        "yyyy/MM/dd HH:mm:ss" 
        "yyyy年MM月dd日 HH时mm分ss"
  注意:
	1.表示模式的字母不能改变(y,M...),字母的连接符号可以改变(-,/...)
    2.表示模式的字母严格区分大小写    

Calendar类

/*
    java.util.Calendar类:日历类
        我们可以使用Calendar类中的方法获取日历上的字段(年,月,日,时,分,秒...)
        我们可以使用Calendar类中的方法修改日历上的字段的值  2020-->2030  4月-->6月
        我们可以使用Calendar类中的方法把日历上字段的值增加|减少  2020-5=2015  4月+3月=7月
        我们可以使用Calendar类中的方法把日历对象转换为Date日期对象
    Calendar 类是一个抽象类,无法直接创建对象使用,在Calendar类中有一个静态方法叫getInstance
        获取Calendar类的子类对象
        static Calendar getInstance() 使用默认时区和语言环境获得一个日历。
    注意:
        西方的月份:0-11月
        东方的月份:1-12月
        西方的星期:星期日-星期六
        东方的星期:星期一-星期日
 */

Math类(重点)


/*
    java.lang.Math类:数学工具类
        Math 类包含用于执行基本数学运算的方法,如初等指数、对数、平方根和三角函数。
        Math类中的方法都是静态方法,通过类名.方法名(参数)可以直接使用
        Math类中私有了构造方法,不让我们直接创建对象使用  private Math() {}
    成员方法:
        public static int abs(int a) 获取参数a的绝对值:
        public static double ceil(double a) 向上取整  1.1 2.0  1.9  2.0
        public static double floor(double a) 向下取整 1.1 1.0  1.99999 1.0
        public static long round(double a) 四舍五入取整  5.5 6   5.49999 5
        public static double pow(double a, double b) 获取a的b次幂  2^3  2^4
 */

System类(重点)

/*
    java.lang.System类
        System 类包含一些有用的类字段和方法。它不能被实例化(私有了构造方法)。
        里边的方法都是静态的,通过类名.方法名(参数)可以直接使用
    成员方法:
        public static void exit(int status) 终止当前运行的 Java 虚拟机,非零表示异常终止
        public static native long currentTimeMillis() 返回当前时间(以毫秒为单位)
        public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)  数组复制
 */

DAY05 BigInteger类、BigDecimal类、Arrays类、包装类、String类、引用类型

学习目标

能够说出BigInteger可以解决的问题
	//可以操作范围超过long类型的整数
	//"11111111232131231233333333333333333333333333333"
能够说出BigDecimal可以解决的问题
	//用于小数(浮点数)的精确计算
能够使用Arrays类的sort方法
	//static void sort(Object[] a) 根据元素的自然顺序对指定对象数组按升序进行排序。
	//int[] arr1 = {1,2,3,7,6,4,9,8,10};
	//Arrays.sort(arr1);
	//[1, 2, 3, 4, 6, 7, 8, 9, 10]
能够使用Arrays类的toString方法
	//static String toString(Object[] a) 对数组进行遍历,把数组中的元素组合成一个字符串返回
	//String s = Arrays.toString(arr);
能够说出自动装箱、自动拆箱的概念
	//在JDK1.5之后,装箱(int-->Integer)与拆箱(Integer-->int)可以自动转换,无需我们调用方法
能够将基本类型转换为对应的字符串
	//1+""  任意的数据类型的值+空字符串,结果都是一个字符串
能够将字符串转换为对应的基本类型
	int i = Integer.parseInt("10");
能够说出String类常用方法的功能及使用
	//String concat(String str) 将指定字符串连接到此字符串的结尾。 把两个字符串连接到一起  "a"+"b"
    //boolean contains(String s)  判断字符串中是否包含指定的字符串;包含返回true,不包含返回false    
    //boolean endsWith(String suffix)  判断字符串是否以指定的字符串结尾;是返回true,不是返回false
    //boolean startsWith(String prefix) 判断字符串是否以指定的字符串开头;是返回true,不是返回false
    //int indexOf(String str) 从前往后在字符串中查找另外一个字符串,找到了返回字符串对应的索引,
    //int lastIndexOf(int ch)  从后往前在字符串中查找另外一个字符串,找到了返回字符串对应的索引,
    //String replace(String target, String replacement)  把大的字符串中所有的目标字符串,替换为新的字符串
    //String substring(int beginIndex) 从开始索引beginIndex截取字符串到字符串的末尾
    //String substring(int beginIndex, int endIndex)  从开始索引beginIndex到结束索引endIndex截取字符串;包含头,不包含尾
    //char[] toCharArray() 将此字符串转换为一个新的字符数组。
    //byte[] getBytes()  查询系统默认的编码把字符串转换为字节数组
    //String toLowerCase()  把字符串中所有的英文字符转换为小写 "abc123你好"==>"ABC123你好"
    //String toUpperCase()  把字符串中所有的英文字符转换为大写 "ABC123你好"==>"abc123你好"
    //String trim() 去掉字符串两端的空格 "       abc   def   www    "==>"abc   def   www"
    //String[] split(String regex)  根据自定的字符串对字符串进行切割
能够在不同的位置使用引用类型
	//引用数据类型和基本数据类型的使用方式是一样的,只是引用数据类型传递都是地址
	//可以作为方法的参数  public static void show(Person p){}
	//可以作为方法的返回值类型 public static Person getPerson{return new Person()}
	//可以作为成员变量 private Person person;

BigInteger类(重点)

java.math.BigInteger 类,不可变的任意精度的整数。如果运算中,数据的范围超过了long类型后,可以使用BigInteger类实现,该类的计算整数是不限制长度的。

BigInteger(String value) 将 BigInteger 的十进制字符串表示形式转换为 BigInteger。超过long类型的范围,已经不能称为数字了,因此构造方法中采用字符串的形式来表示超大整数,将超大整数封装成BigInteger对象。

BigInteger类提供了对很大的整数进行加、减、乘、除的方法,注意:都是与另一个BigInteger对象进行运算。

方法声明描述
add(BigInteger value)返回其值为 (this + val) 的 BigInteger,超大整数加法运算
subtract(BigInteger value)返回其值为 (this - val) 的 BigInteger,超大整数减法运算
multiply(BigInteger value)返回其值为 (this * val) 的 BigInteger,超大整数乘法运算
divide(BigInteger value)返回其值为 (this / val) 的 BigInteger,超大整数除法运算,除不尽取整数部分

BigDecimal类(重点)

/*
    java.math.BigDecimal类
        用于浮点数(小数)的精确计算
        以后想进行小数的精确计算,不要使用float和double,使用BigDecimal类
    构造方法:
        BigDecimal(String val) 将 BigDecimal 的字符串表示形式转换为 BigDecimal。
        参数:
            String val:传递一个字符类型的小数  "1.1"
    成员方法:
        加法:BigDecimal add(BigDecimal augend) 返回一个 BigDecimal,其值为 (this + augend)
        减法:BigDecimal subtract(BigDecimal subtrahend) 返回一个 BigDecimal,其值为 (this - subtrahend),
        乘法:BigDecimal multiply(BigDecimal multiplicand) 返回一个 BigDecimal,其值为 (this × multiplicand),
        除法:BigDecimal divide(BigDecimal divisor) 返回一个 BigDecimal,其值为 (this / divisor)
                如果无法表示准确的商值(除法除不尽 10/3=3.3333333333333),则抛出 ArithmeticException。
            BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)
                返回一个 BigDecimal,其值为 (this / divisor),其标度为指定标度。
                参数:
                    参数:
                        divisor - 此 BigDecimal 要除以的值。
                        scale - 保留的小数位数(2,3,4...)  3.33  3.333
                        roundingMode - 要应用的舍入模式。
                            BigDecimal.ROUND_HALF_UP:四舍五入模式  3.66666666==>3.67  3.333333==>3.3
 */

Arrays类(重点)

/*
    java.util.Arrays:操作数组的工具类
        此类包含用来操作数组(比如排序和搜索)的各种方法。
        Arrays类中的方法都是静态的,可以通过类名.方法名(参数)直接使用
    Arrays类中的成员方法:
         static String toString(Object[] a) 返回指定数组内容的字符串表示形式。
            对数组进行遍历,把数组中的元素组合成一个字符串返回
         static void sort(Object[] a)
            根据元素的自然顺序对指定对象数组按升序进行排序。
 */

包装类

请添加图片描述

/*
    包装类:
        基本数据类型的值(int,double,char,boolean...),使用起来很方便,可以直接使用 10 1.1
        但是没有相关的方法,可以操作这些基本数据类型的值
        所以我们可以使用一个类,把这些基本数据类型的值包裹起来
        在类中定义一些方法,用于操作这些基本数据类型的值
        这个类叫包装类
    基本数据类型:4类8种
        byte    short   int     long    float   double  char        boolean
    基本数据类型对应的包装类: java.lang包
        Byte    Short   Integer Long    Float   Double  Character   Boolean
    java.lang.Integer类:
        Integer 类在对象中包装了一个基本类型 int 的值。
 */
        /*
            装箱:把基本类型的值装到包装类中 int-->Integer
            1.包装类中的构造方法:
                Integer(int value) 传递一个整数
                Integer(String s)  传递字符串类型的整数
            2.包装类中的静态方法:
                static Integer valueOf(int i)  传递一个整数
                static Integer valueOf(String s)  传递字符串类型的整数
            注意:
                两个传递字符串的方法,必须传递整数类型的字符串,否则会抛出异常 "123"  "aaa"
         */
        /*
            拆箱:在包装类对象中取出基本类型的值  Integer==>int
            Integer类中的方法
                int intValue()以 int 类型返回该 Integer 的值。
                long longValue() 以 long 类型返回该 Integer 的值。
         */
/*
    装箱:基本类型-->包装类
    拆箱:包装类-->基本类型
    自动装箱和自动拆箱:在JDK1.5以后,装箱和拆箱可以自动进行,不用我们手动转换
 */
 //自动装箱:基本数据类型自动转换为Integer类型使用 list.add(1); 相当于 list.add(new Integer(1));
        /*
            自动拆箱:Integer类型的数据直接可以变成int类型使用
            int i = list.get(0); 就相当于 int i = list.get(0).intValue();
         */ 
/*
    基本类型与字符串之间的转换(重点,经常使用)
    1.基本数据类型==>字符串
        a.基本数据类型的值+"":工作中最常用  1+""--->"1"
        b.使用包装类Integer中的静态方法toString
            static String toString(int i) 返回一个表示指定整数的 String 对象。
        c.使用String类中的静态方法valueOf
            static String valueOf(int i) 返回 int 参数的字符串表示形式。
    2.字符串类型==>基本数据类型(非常重要)
         在每个包装类中都有一个parseXXX方法,可以把字符串格式的基本类型数据的值,转换为基本数据类型
            Integer类:  static int parseInt(String s)
            Double类:   static double parseDouble(String s)
            ...
         注意:
            1.除了Character类之外,其他所有包装类都具有parseXxx静态方法
            2.字符串必须传递基本数据类型的字符串,否则会抛出数字格式化异常  "100"  "aaa":异常
 */

DAY06 综合案例

DAY07 Collection、Iterator、泛型、数据结构

学习目标

能够说出集合与数组的区别
	数组:
		1.是引用数据类型的一种
		2.可以存储多个元素
		3.数组的长度是固定的 int[] arr1 = new int[10];  int[] arr2 = {1,2,3};
		4.数组即可以存储基本类型的数据,又可以存储引用数据类型的数据
			int[],double[],String[],Student[]
	集合:
		1.是引用数据类型的一种
		2.可以存储多个元素
		3.集合的长度是可以变化的(可以往集合中添加元素,删除集合中的元素)
		4.只能存储引用数据类型的数据
			ArrayList<int> 错误	ArrayList<Integer>	ArrayList<Student>
能够使用Collection集合的常用功能(重点)
	public boolean add(E e) : 把给定的对象添加到当前集合中 。
	public boolean remove(E e) : 把给定的对象在当前集合中删除。
	public boolean contains(Object obj) : 判断当前集合中是否包含给定的对象。
	public boolean isEmpty() : 判断当前集合是否为空。
	public int size() : 返回集合中元素的个数。
	public Object[] toArray() : 把集合中的元素,存储到数组中
	public void clear() :清空集合中所有的元素。
能够使用迭代器对集合进行取元素(重点)
	//1.创建集合对象,往集合中添加元素
	Collection<String> coll = new ArrayList<>();
	//Collection<String> coll = new HashSet<>();
	coll.add("詹姆斯");
	coll.add("姚明");
	coll.add("科比");
	coll.add("乔丹");
	coll.add("艾弗森");
	//2.使用Collection接口中的方法iterator,获取迭代器的实现类对象
	Iterator<String> it = coll.iterator();
	//3.使用迭代器对象Iterator中的方法hasNext和next遍历集合
	while(it.hasNext()){
		String s = it.next();
		System.out.println(s);
	}
能够使用增强for循环遍历集合和数组(重点)
	for(集合|数组中元素的数据类型 变量名: 集合|数组){
		sout(变量名);
	}
	int[] arr = {1,2,3};
	for(int i : arr){
		sout(i);
	}
	ArrayList<String> list = new ArrayList<>();
	list.add("a");
	list.add("b");
	for(String s : list){
		sout(s);
	}
能够理解泛型上下限
    泛型的上限限定: ? extends E ==>传递的未知类型?只能是E的子类或者本身
    泛型的下限限定: ? super E   ==>传递的未知类型?只能是E的父类或者本身
能够阐述泛型通配符的作用
	泛型的通配符: ?  可以接收任意的数据类型
能够说出常见的数据结构
	栈,队列,数组,链表,红黑树
能够说出数组结构特点
	查询快,增删慢
能够说出栈结构特点
	先进后出
能够说出队列结构特点
	先进先出
能够说出单向链表结构特点
	查询慢,增删快

Collection集合

数组:

1.是引用数据类型的一种

2.可以存储多个元素

3.数组的长度是固定的 int[] arr1 = new int[10]; int[] arr2 = {1,2,3};

4.数组即可以存储基本数据类型的数据,又可以存储引用数据类型的数据 int[] double[] String[] Student[]

集合:

1.是引用数据类型的一种

2.可以存储多个元素

3.集合的长度是可以变化的(添加元素,删除集合中的元素)

4.集合只能存储引用数据类型的数据

ArrayList<int> 错误 ArrayList<Integer> ArrayList<Student> ArrayList<String>正确

请添加图片描述

Iterator迭代器

/*
    迭代器:是一种通用取出集合中元素的方式
    迭代器的由来:
        集合有很多种,每种集合的数据结构不同(数组,链表,哈希表...),集合取出元素的方式也不同
        我们不可能为每种集合都定义一种取出元素的方式,浪费
        所以我们可以使用迭代器,是集合通用的取出元素的方式
    迭代器的原理:
        判断集合中还有没有元素,有就取出来;
        再判断集合中还有没有元素,有再取出来;
        一直判断到集合中没有元素为止,这种取出元素的方式叫迭代
    ------------------------------------------------------------------------------------
    java.util.Iterator<E>接口:对 collection 进行迭代的迭代器。
    Iterator接口的常用方法:
        boolean hasNext() 如果仍有元素可以迭代,则返回 true。
            判断集合中还没有没有元素;有返回true,没有返回false
        E next() 返回迭代的下一个元素。 取出集合中的元素
    ------------------------------------------------------------------------------------
    Iterator是一个接口无法创建对象使用,使用Iterator接口的实现类对象,Iterator接口的实现类对象是每个集合的内部类(了解)
    我们可以使用Collection接口中的方法iterator获取迭代器Iterator接口的实现类对象
        Iterator<E> iterator() 返回在此 collection 的元素上进行迭代的迭代器。
    注意:
        我们无需关注iterator方法返回的是接口的哪个实现类对象,我们只需要会使用Iterator接口来接收这个实现类对象即可(多态)
 */
 //注意:迭代器只能使用一次,想要在遍历元素,必须重新获取一个新的迭代器

请添加图片描述
请添加图片描述

/*
    迭代器的并发修改异常:在使用迭代器遍历集合的过程中,对集合长度进行了修改,迭代器就会抛出并发修改异常
    ConcurrentModificationException
    注意:
        1.并发:遍历和修改同时进行
        2.修改:修改集合的长度(添加元素,删除元素)
    解决方案:
        1.遍历集合的同时,不修改集合的长度
        2.Iterator接口有一个子接口叫ListIterator
            在ListIterator接口定义了往集合中添加元素的方法
                public interface ListIterator<E>extends Iterator<E>
                void add(E e)  迭代器中往集合添加元素的方法
                void remove() 删除的是next方法取出的元素
       注意:
        1.如果使用迭代器中的add|remove方法,往集合中添加|删除元素
            就相当于集合和迭代器商量好了,可以往集合中添加|删除元素,迭代器就不会抛出并发修改异常了
        2.ListIterator迭代器只能遍历List接口下的集合(ArrayList,LinkedList),不能遍历Set接口下的集合(HashSet,LinkedHashSet)
 */

迭代器的实现类是每个集合的内部类(了解)
请添加图片描述
注意:

增强for循环底层是一个迭代器,所以在使用增强for循环遍历的时候,不能对集合的长度进行修改,否则会抛出并发修改异常
请添加图片描述

/*
    增强for循环(重点)
        是JDK1.5之后出现的新特性
        使用for循环的方式,对迭代器进行了简化
        增强for循环内部就是一个迭代器,对迭代器进行了封装
   Collection接口有一个父接口叫Iterable
        public interface Collection<E> extends Iterable<E>
        java.lang.Iterable<T>接口
            实现这个接口允许对象成为 "foreach" 语句的目标。
            Collection接口继承了Iterable接口,所以可以使用增强for循环
            Collection接口所有的实现类,都可以使用增强for循环(ArrayList,LinkedList,HashSet...)
   ------------------------------------------------------------
   增强for循环的格式:重点
        for(集合|数组中元素的类型 变量名 : 集合名|数组名){
               sout(变量名);
        }
 */

泛型

请添加图片描述

/*
    java中的泛型:是一个伪泛型,在.java文件中有,但是.class文件中没有
 */
    /*
        使用泛型创建ArrayList集合对象
        好处:
            1.使用什么泛型就只能存储什么类型的数据;避免向下转型抛出类型转换异常
            2.写上泛型存储的是什么类型,取出的就是什么类型,不用向下转型,就可以使用特有的方法
        弊端:
            1.不能什么类型的数据都存储
     */

    /*
        不使用泛型创建ArrayList集合对象
        好处:
            不使用泛型,集合默认的数据类型就是Object类型,可以存储任意数据类型的元素
        弊端:
            1.不能使用元素特有的方法(多态)
            2.在进行向下转型的时候,容易引发类型转换异常
     */

通过反编译软件,查看的class文件中,没有泛型
请添加图片描述

/*
    定义和使用含有泛型的类:模拟ArrayList集合
        当我们不知道使用什么类型的时候,就可以使用泛型,是一个未知的数据类型
        可以给泛型赋值任意的数据类型:Integer,Student,Person,String...
    定义格式:
        public class 类名<泛型>{
            类中使用数据类型的地方,都可以使用类上定义好的泛型
        }
    什么时候确定类上泛型的数据类型
        创建对象的时候,确定类上泛型的数据类型;对象使用什么类型,类的泛型就是什么类型
 */
public class GenericClass<C> {
    private C name;

    public C getName() {
        return name;
    }

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

请添加图片描述

/*
    定义和使用含有泛型的方法(重点)
        泛型需要定义在方法的修饰符和返回值类型之间
    定义格式:
        修饰符 <泛型> 返回值类型 方法名(参数类型-->使用泛型){
            方法体;
        }
    什么时候确定泛型的数据类型:
        调用方法,传递的参数是什么类型,方法的泛型就是什么类型
 */
public class GenericMethod {
    //定义含有泛型的方法(重点)
    public <M> void method01(M m){
        System.out.println(m);
    }

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

    //定义含有泛型的方法,返回值类型使用泛型(了解==>看源码)
    public <AAA> AAA method03(AAA aaa){
        System.out.println(aaa);
        return aaa;
    }
}

请添加图片描述

/*
    定义含有泛型的接口
 */
public interface GenericInterface<I> {
    //定义抽象方法,使用接口上的泛型,作为参数的类型
    public abstract void show(I i);
}
/*
    含有泛型的接口:第一种使用方式
    定义一个类,实现含有泛型的接口,在实现接口的同时,指定接口泛型的数据类型
    格式:
        public class GenericInterfaceImpl1 implements GenericInterface<String>{
            重写接口中的方法,使用指定的类型String
            public void show(String s) { }
        }

        public class GenericInterfaceImpl1 implements GenericInterface<Integer>{
            重写接口中的方法,使用指定的类型Integer
            public void show(Integer integer) { }
        }
 */
public class GenericInterfaceImpl1 implements GenericInterface<Integer>{
    @Override
    public void show(Integer in) {
        System.out.println(in);
    }
}
/*
    含有泛型的接口:第二种使用方式
        定义类实现含有泛型的接口,接口使用什么泛型,实现类就使用什么泛型
        实现类跟着接口走,就和定义一个含有泛型的类是一样的
    格式:
        public class GenericInterfaceImpl2<I> implements GenericInterface<I>{
            重写的方法使用接口上的泛型
            public void show(I i) { }
        }
    注意:
        创建对象的时候,确定泛型的数据类型;创建对象是什么数据类型,泛型就是什么数据类型
 */
public class GenericInterfaceImpl2<I> implements GenericInterface<I>{
    @Override
    public void show(I i) {
        System.out.println(i);
    }
}
/*
    泛型的通配符
        ?:代表可以接收任意的数据类型
        ?已经由java定义好了,我们可以直接使用
 */
        /*
            泛型的通配符只能作为方法参数的数据类型使用,不能创建对象作为数据类型使用
         */
        //ArrayList<?> list = new ArrayList<>();
        //list.add(1);
        //list.add("a");
/*
    泛型通配符的高级使用
    泛型的通配符: ? 代表可以接收任意数据类型的数据
    泛型的上限限定: ? extends E==>传递的未知类型?只能使用E的子类或者是E本身
    泛型的下限限定: ? super E==>传递的未知类型?只能使用E的父类或者是E本身
 */

http://www.kler.cn/a/587326.html

相关文章:

  • 如何用Deepseek制作流程图?
  • 2025年1月-3月Java面试题、笔记、简历模版汇总(需要自取)
  • 解锁C++:指针与数组、字符串的深度探秘
  • MySQL复习(检查本地MySQL是否安装、DataGrip数据库可视化工具使用、增删改查基础语法、唯一索引、SQL简单函数)
  • 【科研绘图系列】R语言绘制网络相关图(cor network plot)
  • 11 | 给 Gin 服务器添加中间件
  • Mac下安装Zed以及Zed对MCP(模型上下文协议)的支持
  • PyQt基础——简单闹钟ui实现(图形化界面、定时器事件)
  • C#的简单工厂模式、工厂方法模式、抽象工厂模式
  • Umi-OCR 全家桶
  • C++20 `<bit>` 中的整数 2 的幂运算和 `std::bit_cast`:由浅入深的探索
  • 定制开发开源 AI 智能名片 S2B2C 商城小程序源码在小程序直播营销中的应用与价值
  • matlab 量化交易投资策略研究
  • 基于 Verilog 的 4 位二进制计数器设计与实验:从理论到实践的深度剖析
  • 数据库版本问题导致的查询bug
  • 宇数科技激光雷达L2
  • 3ds Max 鼠标与快捷键组合操作指南
  • 【愚公系列】《高效使用DeepSeek》009-PPT大纲自动生成
  • DeepSeek:为教培小程序赋能,引领行业变革新潮流
  • DeepSeek对两个网页所描述的数据库高可用方案的分析与比较