javase

方法由对象调用

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法实现对隐藏信息的操作和访问成员变量private，提供对应的**getXxx()/setXxx()**方法

好处：提高了代码的安全性和复用性

 //创建一个学生信息类
public class student {
    //成员变量
    private String name;
  private int age;//设置private关键字，为了防止直接通过对象名访问成员变量可能会造成的数据安全隐患
//提供成员方法（get、set）
      public void setAge(int age)//age为局部变量
      {
            if(0100)
                this.age=age;//this修饰的变量用于指代成员变量。解决局部变量和成员变量同名
            else
                System.out.println("输入的年龄有误");
      }

      public int getAge(){
          return  age;
      }
    
    
    public void setName(String name)
      {
           this.name=name;
      }
    public String getName(){
        return  name;
    }
    
    
    
      //创建show方法
      public void show(){
          System.out.println(name+","+age);
      }
      //有感觉
      private void love(){
          System.out.println("黄婧");
      }
  }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dQ6MmhOm-1646834555133)(C:Users99456Desktop新建文件夹Snipaste_2021-10-30_15-00-44.png)]

方法名为类名

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-T9MC7Nj8-1646834555134)(C:Users99456Desktop新建文件夹Snipaste_2021-10-28_14-04-30.png)]

public class student {
    //成员变量
  private String name;
  private int age;


   public student(){}
 
  public student(String name,int age){
      this.name=name;
      this.age=age;
  }

//ctrl+/--为选中快捷注释
//ctrl+alt+v//--自动添加接收数据的变量
//alt+Fn+ins//--快捷创建构造方法及get/set方法，方法重写
//长按shift+左键最下一行全选
//psvm+回车快速生成 public static void main(String[] args){}
//ctrl+b---访问源码
//shift+Tab--将代码往左移
//alt+鼠标左键--整列编辑
//alt+enter--异常抛出
//ctrl+alt+l//格式化代码

字符串效果上相当于字符数组（char[]),但底层原理是字节数组（byte[])

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zmhN0iKk-1646834555135)(C:Users99456Desktop新建文件夹Snipaste_2021-10-28_16-20-02.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rhsbw9jS-1646834555135)(C:Users99456Desktop新建文件夹Snipaste_2021-10-30_14-17-59.png)]

for(int i=0;i 
字符串比较 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eQ1fe5uV-1646834555135)(C:Users99456Desktop新建文件夹Snipaste_2021-10-30_14-22-35.png)]
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p64SDRNz-1646834555136)(C:Users99456Desktop新建文件夹Snipaste_2021-10-30_14-24-04.png)]
 
拼接字符串 
直接用String类进行拼接，过于浪费空间
 
package string;

public class stringpj {
    public static void main(String[] args){
        char[] arr={'a','b','c'};
      String s=arrayToString(arr);
      System.out.println("s:"+s);
    }
    public static String arrayToString(char[]  arr) {
        String s = "";
        s += "[";
        for (int i = 0; i < arr.length; i++) {
            if (i  == arr.length-1)
                s += arr[i];
            else
            {s += arr[i];
            s += ", ";}
        }
        s += "]";
        return s;
    }
}
 
字符串拼接的理解
 
StringBuilder 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VTkIqWoB-1646834555136)(C:Users99456Desktop新建文件夹Snipaste_2021-10-30_15-53-59.png)]
 
string内容不可变
 
stringBuilder内容可变
 
String类是不可变类，即字符串值一旦初始化后就不可能改变。StringBuffer是可变字符串类，类似String的缓冲区，可以修改字符串的值。
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gFDmJloK-1646834555137)(C:Users99456Desktop新建文件夹Snipaste_2021-10-30_16-00-19.png)]
 
以后就用这种方法来对字符串的操作
 
 
使用
  链式编程（因为append(任意类型)返回对象本身） 
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6EPkyS8U-1646834555137)(C:Users99456Desktop新建文件夹Snipaste_2021-10-30_16-06-38.png)]
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WcF7DUN0-1646834555138)(C:Users99456Desktop新建文件夹Snipaste_2021-10-30_16-16-15.png)]
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uOXZ6UWj-1646834555139)(C:Users99456Desktop新建文件夹Snipaste_2021-10-30_16-15-37.png)]
 
匿名对象 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1zG3oxI9-1646834555139)(C:Users99456Desktop新建文件夹Snipaste_2021-10-30_17-03-56.png)]
 
return new StringBuilder(s).reverse().toString();//中的new StringBuilder(s)及new StringBuilder(s).reverse().toString()为匿名对象
 
集合 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YQYfWwxp-1646834555140)(C:Users99456Desktop新建文件夹Snipaste_2021-11-04_18-19-48.png)]
 
集合类特点：提供一种存储空间可变存储模型，存储的数据容量可以发生改变
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nsjuSRB3-1646834555140)(C:Users99456Desktop新建文件夹Snipaste_2021-11-04_18-24-23.png)]
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9UDJfvhm-1646834555140)(C:Users99456Desktop新建文件夹Snipaste_2021-11-04_18-30-02.png)]
 
//创建一个空集合
 ArrayList<类型> array=new ArrayList<>();
 
继承 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9dsu1YOF-1646834555141)(C:Users99456Desktop新建文件夹Snipaste_2021-11-04_23-15-55.png)]
 
创建一个父类
 
public class Fu{
        public void sd(){
            System.out.println("sd方法已调用");
        }
}
 
创建一个子类
 
public class zi extends Fu {   
    public void sb(){
        System.out.println("sb方法已调用");
    }
}
 
测试
 
public class jic {
    public static void main(String[] args){

        Fu d=new Fu();
        d.sd();

        zi b=new zi();
        b.sb();
        b.sd();

    }
}
 
结果
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BdmxHqxM-1646834555141)(C:Users99456Desktop新建文件夹Snipaste_2021-11-05_18-23-26.png)]
 
继承的好处和弊端 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3fIyVxvN-1646834555141)(C:Users99456Desktop新建文件夹Snipaste_2021-11-05_18-30-04.png)]
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7bPLc1k5-1646834555142)(C:Users99456Desktop新建文件夹Snipaste_2021-11-05_18-35-30.png)]
 
先在方法内寻找被访问的变量->在到子类成员变量中寻找->再到父类成员变量寻找->没有则报错（不考虑父亲的父亲）
 
super 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u8AeLzJM-1646834555142)(C:Users99456Desktop新建文件夹Snipaste_2021-11-05_18-43-52.png)]
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-efP32Onc-1646834555142)(C:Users99456Desktop新建文件夹Snipaste_2021-11-05_18-53-36.png)]
 
重点：子类一定先访问父类的无参的构造方法
 
所以如果想要用带参构造方法创建对象，就要在子类中创建无参和带参构造方法
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tqmzPhd6-1646834555142)(D:java图Snipaste_2021-11-06_21-07-08.png)]
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OcE5nIi2-1646834555143)(D:java图Snipaste_2021-11-06_21-05-56.png)]
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-upZYOtE3-1646834555143)(D:java图Snipaste_2021-11-06_21-04-02.png)]
 
方法重写 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5AaIlnNH-1646834555143)(C:Users99456Desktop新建文件夹Snipaste_2021-11-05_19-18-43.png)]
 
public class zi extends Fu {   
    
    @Override     //有误则重写方法的方法声明有错
    public void sb(){
        System.out.println("sb方法已调用");
    }
}
 
注意事项 
重写函数访问级别限制不能比原函数高。举个例子：如果父类方法声明为公有的，那么子类中的重写方法不能是私有的或是保护的。
 
只有被子类继承时，方法才能被重写。
 
方法定义为final，将导致不能被重写。
 
一个方法被定义为static，将使其不能被重写，但是可以重新声明。
 
一个方法不能被继承，那么也不能被重写。
 
和父类在一个包中的子类能够重写任何没有被声明为private和final的父类方法。
 
和父类不在同一个包中的子类只能重写non-final方法或被声明为public或protected的方法。
 
package 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZBjJHj55-1646834555143)(C:Users99456Desktop新建文件夹Snipaste_2021-11-05_20-39-11.png)]
 
cn.blp 就是cn文件夹里有个blp文件夹
 
导包 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OY54K3G8-1646834555144)(C:Users99456Desktop新建文件夹Snipaste_2021-11-05_20-43-41.png)]
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yMwZwC1S-1646834555144)(C:Users99456Desktop新建文件夹Snipaste_2021-11-05_20-44-01.png)]
 
就像Scanner一样，需要导包
 
权限修饰符 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZEZD4jKD-1646834555144)(C:Users99456Desktop新建文件夹Snipaste_2021-11-05_20-52-23.png)]
 
打钩为可以访问
 
但在不同包中都需要导包
 
Final 
final关键字是最终的意思，可以修饰成员方法，成员变量，类
 
final修饰的特点
 
修饰方法:表明该方法是最终方法,不能被重写修饰变量:表明该变量是常量，不能再次被赋值修饰类:表明该类是最终类,不能被继承 
final修饰局部变量 
 
变量是基本类型: final 修饰指的是基本类型的数据值不能发生改变
  
变量是引用类型: final 修饰指的是引|用类型的地址值不能发生改变,但是地址里面的内容是可以发生改变的
  
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iYpkskRW-1646834555144)(C:Users99456Desktop新建文件夹Snipaste_2021-11-05_21-09-54.png)]
 
s.age可以修改但不能给s重新创建一个地址
 
static 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZFApwtNB-1646834555144)(C:Users99456Desktop新建文件夹Snipaste_2021-11-05_21-22-56.png)]
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vlSBeBI0-1646834555145)(C:Users99456Desktop新建文件夹Snipaste_2021-11-05_21-23-22.png)]
 
静态成员方法只能访问静态成员
 
主方法为静态的成员方法只能访问静态成员，所以在这个类中的方法用static修饰
 
多态 
前提就是继承
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-byNKMJVt-1646834555145)(D:java图Snipaste_2021-11-06_17-05-10.png)]
 
有父类引用指向子类对象
 
动物 animal=new 猫();
 
有继承
 
public class cat extends animal{}
 
多态中成员访问特点 
左-父类，右-子类
 
成员变量:编译看左边，执行看左边
 
成员方法:编译看左边（看父类中是否存在该方法），执行看右边（看子类重写后的方法）
 
父类
 
public class animal{
    private int age=18；
    
    public void eat(){
        System.out.println("动物吃东西")；
    }
}
 
子类
 
public class cat extends animal{
    private String name="猫"；
    private int age=20；
    //方法重写
    public void eat(){
        System.out.println("猫吃鱼")；
    }
    public void play(){
        System.out.println("猫玩球")；
    }
}
 
测试类
 
public class demo{
    public static void main(String[] args){
        animal s=new cat();
        //成员变量
       System.out.println(s.age)；     //输出18
！           System.out.println(s.name)；//报错，因为父类中没有name这个成员变量
          
        //成员方法
        s.eat();  //输出：猫玩球。
!        s.play();//报错，因为父类中没有play()这个成员方法
        
           
 
为什么成员变量和成员方法的访问不一样呢?
 因为成员方法有重写，而成员变量没有
 
多态的好处和弊端 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cwj7AkiR-1646834555145)(D:java图Snipaste_2021-11-06_17-55-04.png)]
 
动物类
 
public class animal{
    
    public void eat(){
        System.out.println("动物吃东西");
    }
   public void play(){
        System.out.println("动物爱玩");
    }
    public void like(){
        System.out.println("动物喜欢运动");
    }
}
 
猫类
 
public class cat extends animal{

//方法重写
public void eat(){
        System.out.println("猫吃鱼");
        }
public void play(){
        System.out.println("猫玩球");
        }
    public void like(){
        System.out.println("猫喜欢睡觉");
    }

        }
 
狗类
 
public class dog extends animal{
       
        //方法重写
        public void eat(){
            System.out.println("狗吃骨头");
        }
        public void play(){
            System.out.println("狗接飞盘");
        }
        public void like(){
            System.out.println("狗喜欢跑步");
        }

    }
 
动物操作类
 
public class useAnimal {
    public void use(animal a){
        // animal a=new cat();
       // animal o=new dog();
        a.eat();
        a.play();
        a.like();
    }
}
 
测试类1
 
public class demo {
    public static void main(String[] args) {
        useAnimal ao=new useAnimal();
        cat c=new cat();
        ao.use(c);
        dog d=new dog();
        ao.use(d);
    }
}
 
如果不创建操作类
 
测试类2
 
 public class demo {
    public static void main(String[] args) {
        dog a=new dog();
        cat o=new cat();
        
        a.like();
        a.eat();
        a.play();
        
        o.eat();
        o.play();
        o.like();
    }
}
 
每增加一种动物都要创建一个对象和调用多个方法(前提调用的方法相同），更麻烦。
 
向上转型 
解决不能使用子类的特有功能
 
animal o=new dog();//向上转型

dog a=(dog)o;//向下转型  可以不用在创建一个新的dog对象
 
抽象类 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eUv6aCJA-1646834555146)(D:java图Snipaste_2021-11-06_18-54-13.png)]
 
1.2抽象类的特点
 抽象类和抽象方法必须使用abstract关键字修饰
 public abstract class类名书
 public abstract void eat());
 
public abstract class animal{
    public abstract void eat();
}
 
抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
 
抽象类不能实例化----即不能创建对象
 
animal a=new animal();//错误
 
抽象类如何实例化呢?参照多态的方式，通过子类对象实例化,这叫抽象类多态
 
public class cat extends animal{}
 
抽象类的子类
 
​ 要么重写抽象类中的所有抽象方法。(强制子类重写该方法)
 
​ 要么是抽象类。即用abstract 修饰子类
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JXUdPPHQ-1646834555146)(D:java图Snipaste_2021-11-06_19-20-59.png)]
 
接口 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-du4Ey9OL-1646834555147)(D:java图Snipaste_2021-11-06_19-47-14.png)]
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NCY1OXGR-1646834555147)(D:java图Snipaste_2021-11-06_19-52-59.png)]
 
接口成员特点 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aZ9c1UXM-1646834555147)(D:java图Snipaste_2021-11-06_20-16-35.png)]
 
//成员变量
public static final int age=19;
等于
int age=19;
 
一个类如果没有父类，默认继承Object类
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2WRNzALx-1646834555147)(D:java图Snipaste_2021-11-06_20-20-27.png)]
 
​ 实现/子类 父类 接口
 
接口和抽象类的区别 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9gMrvV4G-1646834555148)(D:java图Snipaste_2021-11-06_21-23-32.png)]
 
继承只能单继承
 
eg:门的功能有开，关，有的门能报警
    如果单独用一个抽象类或接口来对这三种行为抽象，那么门必须都强制具备开关和报警，但有的门没有
    如果用三个抽象类来对这三种行为抽象，则无法继承三个
    最好的方法是开关用抽象类，报警用接口
    
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wO0lHS7j-1646834555148)(D:java图Snipaste_2021-11-06_21-36-22.png)]
 
类名作为形参和返回值 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DQEZx4uJ-1646834555148)(D:java图Snipaste_2021-11-07_19-26-46.png)]
 
狗类
 
public class dog {
    public void eat(){
            System.out.println("狗吃骨头");
        }
}
 
操作类
 
public class usedog{
   public void udog(dog c){//作为形参
       //dog d=new dog();----创建dog对象，只有对像才能调用方法
       d.eat();
   }
    
  public dog getdog(){  //作为返回值
      dog d=new dog();
      return d;
  }  
}
 
测试类
 
public class demo {
    public static void main(String[] args) {
        usedog a=new usedog();
        dog d=new dog();
        a.udog(d);   

        dog o=a.getdog();
        d.eat;
    }
}

 
抽象类名作为形参和返回值 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w4o4UVDF-1646834555148)(D:java图Snipaste_2021-11-07_19-30-19.png)]
 
可以理解为抽象类名作为形参和返回值时要用到抽象多态创建一个子类或使用匿名内部类
 
接口类名作为形参和返回值 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qFgUPOVu-1646834555148)(D:java图Snipaste_2021-11-07_19-56-53.png)]
 
和抽象类的用法类似
 
内部类 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nQEQNEmf-1646834555149)(D:java图Snipaste_2021-11-07_20-38-22.png)]
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1clvGVsi-1646834555149)(D:java图Snipaste_2021-11-07_20-37-37.png)]
 
成员内部类-----在类的成员变量位置—如图
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qBK5205m-1646834555149)(D:java图Snipaste_2021-11-07_20-48-29.png)]
 
内部类一般以private修饰，不让外界访问，那么如何使用内部类呢？那就在外部类中创建一个方法，创建一个内部类的方法，在访问内部类的方法。而外界使用时只需创建外部类对象在调用方法。
 
如果是public修饰的呢？
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-O08VpjGA-1646834555150)(D:java图Snipaste_2021-11-07_20-44-25.png)]
 
局部内部类-----在类的局部位置（成员方法）
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iGeJkBdO-1646834555150)(D:java图Snipaste_2021-11-07_22-07-03.png)]
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SqUN4axB-1646834555150)(D:java图Snipaste_2021-11-07_22-07-22.png)]
 
匿名内部类 
特殊的局部内部类
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vDXFKPXr-1646834555150)(D:java图Snipaste_2021-11-07_22-10-48.png)]
 
注意他是一个对象
 
别忘加“；”
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uoCrJh6q-1646834555150)(D:java图Snipaste_2021-11-07_22-17-55.png)]
 
此Inter为一个接口，i用来接收此对象的数据（new Inter()）
 
匿名内部类在开发中的使用(免去创建子类或实现) 
接口
 
public interface jumpping {
    void jump();
}
 
操作类
 
public class use {
    public void method(jumpping j){
        j.jump();
    }
}
 
测试类
 
public class demo {
    public static void main(String[] args) {
            use u=new use();
            u.method(new jumpping() {
                @Override
                public void jump() {
                    System.out.println("匿名内部类");
                }
            });
    }
}
 
不用匿名内部类
 
接口
 
public interface jumpping {
    void jump();
}
 
操作类
 
public class use {
    public void method(jumpping j){
        j.jump();
    }
}
 
实现
 
public class zi implements jumpping(){
    
    public void jump() {
                    System.out.println("接口多态");
                } 
}
 
测试类
 
public class demo {
    public static void main(String[] args) {
            use u=new use();
            zi d=new zi();
        u.method(d);
    }
}
 
接口作为形参，为了使用接口里的jump方法，于是用的匿名内部类，不必再创建一个实现类
 
Math类 
该类为final类所以无子类
 
方法都被static修饰所以不需要创建对象，用类名调用即可
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-usymxJjP-1646834555150)(D:java图Snipaste_2021-11-08_09-19-07.png)]
 
System.out.println(Math.abs(-88));//取绝对值

System.out.println((int)Math.random()*100+1);//取0到100的随机整数
 
System类 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CjJVDOsI-1646834555150)(D:java图Snipaste_2021-11-08_09-33-37.png)]
 
 System.exit(0);//JVM退出--虚拟机退出

//计算程序运行的时间
long l = System.currentTimeMillis();
        for (int i=0;i<10000;i++){
            System.out.println(i);

        }
        long l1 = System.currentTimeMillis();
        System.out.println(l1-l);

 System.out.println(System.currentTimeMillis()*1.0/1000/6024);//计算1970年到当前时间天数
 
Object中的toString()方法 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1bLNSsgr-1646834555151)(D:java图Snipaste_2021-11-08_22-15-10.png)]
 
也就是说子类都可以使用toString()方法,建议子类重写该方法，如何重写呢？ait+fn+ins自动生成
 
@Override
    public String toString() {
        return "Fu{" +
                "name='" + name + ''' +
                ", age=" + age +
                '}';
    }
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IvnHv79P-1646834555151)(D:java图Snipaste_2021-11-08_22-30-28.png)]
 
更直观。
 
Object中的equals()方法 
子类都可以使用equals()方法,建议子类重写该方法，如何重写呢？ait+fn+ins自动生成
 
@Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Fu fu = (Fu) o;

        if (age != fu.age) return false;
        return name != null ? name.equals(fu.name) : fu.name == null;
    }
 
student s1=new student();
s1.setAge(18);
s1.setName("blp");

student s2=new student();
s2.setAge(15);
s2.setName("blx");

//比较s1和s2是否内容相等
System.out.println(s1.equal(s2));//如果不重写使用此方法比较的是地址，重写后才比较的是内容
 
冒泡法 
java中的数组空间不可变i+1容易越界，c语言则不会
public class bijjiao {
    public static void main(String[] args) {
        int[] arr={12,32,11,45,56,77};
        System.out.println("排序前arr="+shuchu(arr));

        for (int j=0;jarr[i+1]){               //java中的数组空间不可变i+1容易越界，c语言则不会
                int sum=arr[i+1];
                arr[i+1]=arr[i];
                arr[i]=sum;
            }
        }
        System.out.println("排序前arr="+shuchu(arr));

    }

//将数组转换为字符串
    public static String shuchu(int[] arr){
        StringBuilder s=new StringBuilder();
        s.append("[");
        for (int i=0;i 
#include
main(){
	int a[]={12,13,21,32,11,14};
	int i,m,j;
	for(j=0;j<6;j++)
	for(i=0;i<6;i++){
		if(a[i]>a[i+1]){
		    m=a[i+1];
			a[i+1]=a[i];
			a[i]=m;	
		}
	}
	for(i=0;i<6;i++)
	{
		printf("%dn",a[i]);
	}
} 
 
arrays类 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YwkvVEK2-1646834555152)(D:java图Snipaste_2021-11-08_23-37-36.png)]
 
于是上述冒泡法可写成
 
import java.util.Arrays;
public class bijjiao {
    public static void main(String[] args) {
        int[] arr={12,32,11,45,56,77};
        System.out.println("排序前arr="+ Arrays.toString(arr));
        Arrays.sort(arr);
        System.out.println("后arr="+Arrays.toString(arr));}
}
 
基本类型包装类 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dBL8pRa5-1646834555152)(D:java图Snipaste_2021-11-08_23-51-32.png)]
 
简单来说将基本类型进行包装可以定义更多的功能方法操作该数据，方便
 
Integer类 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GKSS9Ngy-1646834555152)(D:java图Snipaste_2021-11-08_23-53-49.png)]
 
创建对象
 
        Integer s1=Integer.valueOf(100);
        System.out.println(s1);
        Integer s2=Integer.valueOf("100");
        System.out.println(s2);
 
Integer.parsrInt()返回的是int类型，Integer.valueOf()返回的是Integer，将String转换为int类型
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qOIRm7Ny-1646834555153)(D:java图Snipaste_2021-11-09_00-37-42.png)]
 
字符串中字符排序 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iN5cfsns-1646834555153)(D:java图Snipaste_2021-11-10_11-53-29.png)]
 
split(String ergex)中的regex为字符之间的隔开符号，如这里用split(" “);有的用split(”,");
 
自动装箱和拆箱 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AK3n2Jp0-1646834555153)(D:java图Snipaste_2021-11-10_12-15-04.png)]
 
简化了装箱拆箱的操作
 
//进行不为null的判断
if(i!=null){}
 
Date 
构造方法 
import java.util.Date;
public class bijjiao {
    public static void main(String[] args) {
        Date d=new Date();       //当前时间
        System.out.println(d);

        long d1=1000*60*60;
        Date d2=new Date(d1);
        System.out.println(d2);
    }
}
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S1vlFZhK-1646834555153)(D:java图Snipaste_2021-11-10_12-57-36.png)]
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yhsgvE52-1646834555154)(D:java图Snipaste_2021-11-10_12-58-10.png)]
 
本来是1点但是这不是北京时间，所以有时差。在date中重写了toString()方法输出时调用了toString()方法
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ARBPJRhb-1646834555154)(D:java图Snipaste_2021-11-10_13-02-36.png)]
 
import java.util.Date;

public class bijjiao {
    public static void main(String[] args) {
        Date d = new Date();
        System.out.println(d.getTime());
        System.out.println(d.getTime() * 1.0 / 1000 / 60 / 60 / 24 / 365+"年");
    }
}
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SDTNNXS1-1646834555155)(D:java图Snipaste_2021-11-10_13-16-05.png)]
 
SimpleDateFormat 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UnB6aS2N-1646834555155)(D:java图Snipaste_2021-11-11_20-48-15.png)]
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5aRcMNVF-1646834555155)(D:java图Snipaste_2021-11-11_20-47-42.png)]
 
import java.util.Date;
import java.text.SimpleDateFormat;

public class bijjiao {
    public static void main(String[] args) {
        Date d=new Date();
        SimpleDateFormat s=new SimpleDateFormat();//默认模式
        String v = s.format(d);
        System.out.println(v);
    }
}
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LhVCFuEQ-1646834555156)(D:java图Snipaste_2021-11-11_21-02-46.png)]
 
给定模式
 
import java.util.Date;
import java.text.SimpleDateFormat;

public class bijjiao {
    public static void main(String[] args) {
        Date d=new Date();
        SimpleDateFormat s=new SimpleDateFormat("yyyy年MM月dd日HH时mm分ss秒");
        String v = s.format(d);
        System.out.println(v);
    }
}
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FvnG1ZIe-1646834555156)(D:java图Snipaste_2021-11-11_21-07-45.png)]
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uLtKJiAJ-1646834555156)(D:java图Snipaste_2021-11-11_20-49-23.png)]
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dbv8gEx2-1646834555156)(D:java图Snipaste_2021-11-11_21-11-34.png)]
 
格式化如上代码
 
解析
 
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class bijjiao {
    public static void main(String[] args) throws ParseException {
        String s="2021-11-11 21:14:00";
        SimpleDateFormat ss = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //格式要和上面字符串一样
        Date v = ss.parse(s);
        System.out.println(v);
    }
}
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lGNkTD3z-1646834555156)(D:java图Snipaste_2021-11-11_21-42-54.png)]
 
时间工具类 
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Datetool {

    private Datetool() {}

    public static String DateToString(Date date,String p){
        SimpleDateFormat d=new SimpleDateFormat(p);
        String s = d.format(date);
        return s;
    }
    public static Date StringToDate(String b,String p) throws ParseException {
        SimpleDateFormat d=new SimpleDateFormat(p);
        Date s = d.parse(b);
        return s;
    }
}
 
直接用类名调用方法
 
import java.text.ParseException;
import java.util.Date;

public class Datedemo {
    public static void main(String[] args) throws ParseException {
        Date d=new Date();
        String p="yyyy年MM月dd日 HH:mm:ss";
        String z = Datetool.DateToString(d, p);
        System.out.println(z);

        String a="2022-11-22 22:22:00";
        String e="yyyy-MM-dd HH:mm:ss";
        Date w = Datetool.StringToDate(a, e);
        System.out.println(w);
    }
}
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QMJAiLT9-1646834555157)(D:java图Snipaste_2021-11-11_23-37-40.png)]
 
Calendar类(抽象类) 
也叫做日历类
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-csg0NU53-1646834555157)(D:java图Snipaste_2021-11-11_23-59-34.png)]
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wvLTVYeU-1646834555157)(D:java图Snipaste_2021-11-11_23-53-03.png)]
 
构造方法，因为是抽象类所以要创建一个子类来构造方法
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XUmwh2Ru-1646834555157)(D:java图Snipaste_2021-11-12_00-11-31.png)]
 
import java.util.Calendar;

public class Calenda {
    public static void main(String[] args) {
        Calendar d = Calendar.getInstance();
        
        int year = d.get(Calendar.YEAR);
        int mouth = d.get(Calendar.MARCH)+1;//月份要加一,从0开始
        int date = d.get(Calendar.DATE);

        System.out.println(year + "年" + mouth + "月" + date + "日");
    }
}
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-syfvM2Lm-1646834555158)(D:java图Snipaste_2021-11-12_01-06-11.png)]
 
d.add(Calendar.DATE,-3);//往后减3天，查看前三天的日期
 
设置日期 
import java.util.Calendar;

public class Calenda {
    public static void main(String[] args) {
        Calendar d = Calendar.getInstance();

        d.set(1900,12,11);
        int year = d.get(Calendar.YEAR);
        int mouth = d.get(Calendar.MARCH)+1;
        int date = d.get(Calendar.DATE);
        System.out.println(year + "年" + mouth + "月" + date + "日");
    }
}
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S1KzTUUX-1646834555158)(D:java图Snipaste_2021-11-12_01-13-04.png)]
 
求某一年的2月份有几天 
这一年的3月1号前一天就是2月份的天数
 
mport java.util.Calendar;
import java.util.Scanner;

public class Calenda {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);

        System.out.println("请输入年份：");
        int year=sc.nextInt();

        Calendar d = Calendar.getInstance();

        d.set(year,2,1);

        d.add(Calendar.DATE,-1);
        int date = d.get(Calendar.DATE);

        System.out.println(year+"年2月份有"+date+"天");
    }
}
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mN2bcSUR-1646834555159)(D:java图Snipaste_2021-11-12_01-31-26.png)]
 
异常 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wf0zg4Qt-1646834555159)(D:java图Snipaste_2021-11-12_22-41-02.png)]
 
ArrayIndexOutOfBoundsException–这个就是数组索引越界异常
 
JVM在面对异常的默认处理方案 
把程序的名称，异常原因及异常出现的位置等信息输出在控制台程序停止执行 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HjmuYL3N-1646834555159)(D:java图Snipaste_2021-11-12_22-50-52.png)]
 
处理异常–try{}catch(){} 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-91F3fTD1-1646834555159)(D:java图Snipaste_2021-11-12_22-57-46.png)]
 
public class Calenda {
    public static void main(String[] args) {
        System.out.println("开始");
    method();
        System.out.println("结束");

    }
    public static void method(){
        try {
            int[] d={1,2,3,4};
            System.out.println(d[4]);
        }catch (ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
        }
    }
}
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hZYCfVRx-1646834555159)(D:java图Snipaste_2021-11-12_23-07-57.png)]
 
用try—catch后程序可以运行不会中途退出，最好用printStackTrace();方法，提示信息最全
 
编译时异常和运行时异常的区别 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XhU9rlJv-1646834555160)(D:java图Snipaste_2021-11-12_23-34-21.png)]
 
异常处理之throws 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CK9KX3ni-1646834555160)(D:java图Snipaste_2021-11-12_23-43-34.png)]
 
在编译时出现异常alt+enter选择两种方法中的一种进行处理
 
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;

public class Calenda {
    public static void main(String[] args) throws ParseException {
        method();
        System.out.println("ss");
    }
    public static void method() throws ParseException {
        String s="2002-12-11";
        SimpleDateFormat D=new SimpleDateFormat("yyyy-MM-dd");
        Date a = D.parse(s);
        System.out.println(a);

    }}
//在方法中丢出异常最后还是用调用者处理
 
自定义异常 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a57piFTp-1646834555160)(D:java图Snipaste_2021-11-12_23-55-22.png)]
 
自定义异常
 
public class ScoreException extends Exception{
    public ScoreException() {
    }
    public ScoreException(String message) {
        super(message);
    }
}
 
调用异常
 
public class Teacher {
    public void checkScore(int score) throws ScoreException {
        //注意throws ScoreException
        if (0 
测试
 
import java.util.Scanner;

public class testq {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);

        System.out.println("请输入学生成绩：");
        int score = sc.nextInt();

        Teacher t=new Teacher();
        try {
            t.checkScore(score);
        } catch (ScoreException e) {
            e.printStackTrace();
        }

    }
}
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7J6sUgVF-1646834555161)(D:java图Snipaste_2021-11-13_00-30-11.png)]
 
集合体系结构 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-03QlOTyQ-1646834555161)(D:java图Snipaste_2021-11-14_21-24-17.png)]
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4mvKEoDz-1646834555161)(D:java图Snipaste_2021-11-14_21-30-14.png)]
 
import java.util.ArrayList;

public class fsf {
    public static void main(String[] args) {
        ArrayList c=new ArrayList<>();
        
        c.add("hello");
        c.add("word");

        System.out.println(c);
    }
}
 
重写了toString()方法
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7H9lU70k-1646834555161)(D:java图Snipaste_2021-11-14_21-36-13.png)]
 
Collection集合常用方法
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qcqSVIMv-1646834555162)(D:java图Snipaste_2021-11-14_21-37-08.png)]
 
其中remove()在list的实现类创建的集合中，如果集合中要去除的元素有多个则去除第一个
 
import java.util.ArrayList;

public class fsf {
    public static void main(String[] args) {
        ArrayList c=new ArrayList<>();


        c.add("hello");
        c.add("word");
        c.add("d");
        c.add("word");
        c.add("c");
        c.add("word");

        c.remove("word");
        System.out.println(c);
    }
}
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gedIKA1B-1646834555162)(D:java图Snipaste_2021-11-14_21-59-28.png)]
 
Collection集合的遍历 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Hfb9d30A-1646834555162)(D:java图Snipaste_2021-11-14_22-40-36.png)]
 
import java.util.ArrayList;
import java.util.Iterator;

public class fsf {
    public static void main(String[] args) {
        ArrayList c=new ArrayList<>();


        c.add("hello");
        c.add("word");
        c.add("d");
        c.add("word");
        c.add("c");
        c.add("word");


        Iterator ct=c.iterator();

        while (ct.hasNext()){
            //System.out.println(ct.next());
            String s=ct.next();
            System.out.println(s);
        }


        System.out.println(c);
    }
}
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-f3xivlU8-1646834555162)(D:java图Snipaste_2021-11-14_22-48-46.png)]
 
Collection集合存储学生类对象 
学生类
 
操作类
 
import java.util.ArrayList;
import java.util.Iterator;

public class fsf {
    public static void main(String[] args) {
        ArrayList c=new ArrayList<>();
        student s1=new student("包乐培","18");
        student s2=new student("黄婧","19");

        c.add(s1);
        c.add(s2);

        Iterator d=c.iterator();

        while (d.hasNext()){
            student q = d.next();
            System.out.println(q.getName()+","+q.getAge());
        }
    }
}
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Y1d1vWZW-1646834555163)(D:java图Snipaste_2021-11-14_23-19-34.png)]
 
 
在 Iterator迭代器其中无add方法。
 
list 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nwFPZEOF-1646834555163)(D:java图Snipaste_2021-11-16_23-33-45.png)]
 
//创建对象
List d = new ArrayList<>();
 
ListIterator 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-A10cu1E2-1646834555163)(D:java图Snipaste_2021-11-17_21-55-24.png)]
 
ListIterator a= d.listIterator();

        while (a.hasNext()){
            String s = a.next();
            if (s.equals("你")){   //有"你”时"平静"
                a.add("平静");
            }
        }
 
增强for(最方便的遍历方式只为了遍历) 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IS3gycSd-1646834555163)(D:java图Snipaste_2021-11-17_22-07-25.png)]
 
public class list {
    public static void main(String[] args) {

        int[] a={1,12,13,12};
        for (int d:a){
            System.out.println(d);
        }
    }
}
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mRr9Aobf-1646834555163)(D:java图Snipaste_2021-11-17_22-11-39.png)]
 
遍历的3种方式 
 
Iterator迭代器为集合特有的遍历方式(也只为遍历)
  
for循环带索引
  
增强for只为遍历
  
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OOK7jU0O-1646834555167)(D:java图Snipaste_2021-11-17_22-32-09.png)]
 
linkedList特有功能 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oROQAmp6-1646834555167)(D:java图Snipaste_2021-11-17_22-36-39.png)]
 
Set集合 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pa0LR0SP-1646834555167)(D:java图Snipaste_2021-11-19_21-26-42.png)]
 
import java.util.*;

public class list {
    public static void main(String[] args) {
        Set d=new HashSet<>();

        d.add("再见");
        d.add("欺骗");
        d.add("好累");

        //增强for
        for (String s:d){
            System.out.println(s);
        }
    }
}
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xiM3X2Gz-1646834555167)(D:java图Snipaste_2021-11-19_21-35-23.png)]
 
因为不带索引，所以不能用普通的for循环遍历，遍历时也是无序的
 
哈希值 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tJpIuEOE-1646834555167)(D:java图Snipaste_2021-11-19_21-44-43.png)]
 
public class list {
    public static void main(String[] args) {
        System.out.println("再见".hashCode());
        System.out.println("好傻".hashCode());
        System.out.println("----------");
        System.out.println("重地".hashCode());
        System.out.println("通话".hashCode());
    }
}
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MfxULUxO-1646834555167)(D:java图Snipaste_2021-11-19_21-50-08.png)]
 
不同对象的哈希值不一定不想提，但相同对象的哈希值一定相同。如果要使对象不相同的哈希值相同则重写hashCode()方法
 
学生类(未重写hashCode()方法)
 
测试类
 
public class list {
    public static void main(String[] args) {
        Student d1=new Student("大",13);
        Student d2=new Student("防",12);

        System.out.println(d1.hashCode());
        System.out.println(d2.hashCode());
    }
}
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-G41Ko7e5-1646834555167)(D:java图Snipaste_2021-11-19_22-03-17.png)]
 
在学生类中重写hashCode()方法
 
public int hashCode(){
        return 0;
    }
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-N0tBGNOF-1646834555169)(D:java图Snipaste_2021-11-19_22-06-31.png)]
 
HashSet集合(无索引) 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jSHJLtdK-1646834555169)(D:java图Snipaste_2021-11-19_22-08-58.png)]
 
构造方法
 
HashSet d=new HashSet<>();
 
shift+Tab–将代码往左移
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wbLWKPrI-1646834555169)(D:java图Snipaste_2021-11-19_22-15-37.png)]
 
HashSet集合保证元素唯一性源码分析(面试题) 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-16CduCKJ-1646834555169)(D:java图Snipaste_2021-11-19_22-47-13.png)]
 
数据结构之哈希表（用来存储Set集合的内容） 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-piwTfnWt-1646834555169)(D:java图Snipaste_2021-11-19_23-02-07.png)]
 
这就是解释为什么要进行位置的查找和判断是否有值
 
HashSet集合存储学生信息 
在学生类中自动重写hashCode()和equals()
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YKFTKFQd-1646834555170)(D:java图Snipaste_2021-11-19_23-34-02.png)]
 
linkedHashSet集合(有序，存储和取出顺序) 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-T5zeKb6k-1646834555170)(D:java图Snipaste_2021-11-19_23-39-23.png)]
 
构造方法
 
linkedHashSet b=new linkedHashSet<>();
 
TreeSet集合(有序，取决于构造方法) 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0cuoajSM-1646834555170)(D:java图Snipaste_2021-11-19_23-49-14.png)]
 
自然排序
 
import java.util.*;
public class list {
    public static void main(String[] args) {
        TreeSet a=new TreeSet<>();//当存储基本类型时要将其转换为对应的包装类型
        a.add(12);//自动装箱
        a.add(14);
        a.add(13);
        a.add(11);
        for (Integer s:a){
            System.out.println(s);
        }
    }
}
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EcQWalbF-1646834555171)(D:java图Snipaste_2021-11-19_23-57-12.png)]
 
自然排序Comparable的使用 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Fi0hIVcY-1646834555172)(D:java图Snipaste_2021-11-20_21-38-04.png)]
 
public class Student implements Comparable {    //实现Comparable接口
    
    @Override
    public int compareTo(Student s) {       //重写compareTo方法
        int b = this.age-s.age;    
        // this.age相当于d2  s.age相当于d1  从小到大排序
        int i = b == 0 ? this.name.compareTo(s.name) :b;
        return i;
    }
}
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JSPIwgey-1646834555172)(D:java图Snipaste_2021-11-20_21-54-26.png)]
 
比较排序 Comparator的使用 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Nvnymqxp-1646834555172)(D:java图Snipaste_2021-11-21_10-09-25.png)]
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Jz12iKFL-1646834555172)(D:java图Snipaste_2021-11-21_09-59-53.png)]
 
匿名内部类的方法实现 Comparator接口
 
 TreeSet d=new TreeSet<>(new Comparator(){
            @Override
            public int compare(Student s1, Student s2) {
                int i = s1.getAge() - s2.getAge();
                int i1 = i == 0 ? s1.getName().compareTo(s2.getName()) : i;
                return i1;
            }
        });   //别忘了;   无法直接访问所以用调方法的方式访问
 
Random随机数 
Random b=new Random();
        int i = b.nextInt(20) + 1;  //不加1时是0到19，加上后是1到20
 
泛型 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TVtt0dRE-1646834555173)(D:java图Snipaste_2021-11-21_10-31-10.png)]
 
泛型类 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-49PDF7aG-1646834555173)(D:java图Snipaste_2021-11-21_10-39-13.png)]
 
public class Generic{
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}
 
使用
 
Generic d=new Generic<>();
        d.setT("dad");
 
泛型方法 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7gTa10Lm-1646834555173)(D:java图Snipaste_2021-11-21_10-57-31.png)]
 
创建泛型方法
 
public class Generic{
    public  void show(T t){
        System.out.println(t);
    }
    }
 
 Generic b=new Generic();
        b.show(13);
        b.show("dsd");
        b.show(12.1);
 
泛型接口 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6Jw8QYyn-1646834555173)(D:java图Snipaste_2021-11-21_11-09-13.png)]
 
接口
 
public interface Generic {
    void show(T t);
}
 
接口实现类
 
public class GenericImpl  implements Generic{   //Impl表示实现接口类
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}
 
类型通配符(作用未知) 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xzbPrgXM-1646834555174)(D:java图Snipaste_2021-11-21_20-53-57.png)]
 
8种基本类型的包装类 
 List d=new ArrayList();
        List d1=new ArrayList();
        List d2=new ArrayList