Java深层知识点（上）

乱七八糟的定义

方法重载

    public static int sum(int a, int b){
        return a+b;
    }
    public static int sum(int a, int b, int c){
        return a+b+c;
    }

    public static void main(String[] args) {
        System.out.println(sum(1,2));
        System.out.println(sum(1,2,3));
    }

基本、引用数据类型

权限修饰符

private age;

使用setAge()

 就近原则、this关键字 

this用来区分成员和局部变量

public class Test {
    private int a = 10;
    public void fun(){
        int a = 12;
        System.out.println(a);  // 12
        System.out.println(this.a);  // 10
    }
}

  this

this指当前对象的地址

 static

静态变量用类名调用

 静态方法内没有this？

因为方法是和对象相关的，静态方法不管对象，直接调

 工具类

不让别人创建对象

 多态

多态调用成员乱规则 

  

public class duotai {
    public static void main(String[] args) {
        Animal a = new Dog();
        //调用成员变量，编译看左，运行看左
        System.out.println(a.name);  // animal
        //调用成员方法，编译看左，运行看右
        a.show();  //dog--show
        //要是右边没有这个方法，就是还是调用父类的方法，要父类是private，寄
    }

}

class Animal{
    String name = "animal";
    void show(){
        System.out.println("animal--show");
    }
}

class Cat extends Animal{
    String name = "Cat";
    void show(){
        System.out.println("cat--show");
    }
}

class Dog extends Animal{
    String name = "Dog";
    void show(){
        System.out.println("Dog--show");
    }
}

 final

修饰引用类型，地址不能变，指向的对象可以变

构造器

@ 任何类定义出来，默认就自带了无参数构造器，写不写都有。

@ 一旦定义了有参数构造器，那么无参数构造器就没有了，如果还想用无参数构造器，此时就需要自己手写一个无参数构造器了。

JavaBean

 1、成员变量建议使用private（name, age, sex）

 2、为成员变量提供成套的get/set方法

 3、要求提供无参构造器

常量

使用public static final修饰的成员变量，必须有初始化值，执行的过程中其值不能被改变。

做系统的配置信息，方便程序的维护，同时也能提高可读性。

数组

静态、动态初始化

//静态初始化
    //完整格式
    int[] arr = new int[]{1, 2, 3, 4, 5};
    //简写
    char[] carr = {'a', 'b', 'c', 'd', 'e'};
//动态初始化  指定长度
    int[] arr2 = new int[3];
    arr2[0] = 1;
    arr2[1] = 2;        

String

String其实常被称为不可变字符串类型，它的对象在创建后不能被更改。

 创建对象

@ 以""方式给出的字符串对象，在字符串常量池中存储，相同内容只会在其中存储一份。
@ 通过构造器new对象，每new一次都会产生一个新对象，放在堆内存中。

 题目

---

常用API 

账号密码

验证码

 ArrayList

数组：类型确定，数据确定

ArrayList：大小不固定，类型不固定

创建 

  泛型

存储自定义类型

 

API

 Arrays

数组操作工具类，用于操作数组元素

 自定义排序规则

  自己理解

public static void main(String[] args) {
        Integer[] arr = {5,8,6,23,5,89,4,15};
        /**
         * 必须是引用类型
         */
        Arrays.sort(arr, new Comparator<Integer>(){
            @Override
            public int compare(Integer o1, Integer o2){
                /*if(o1>o2)
                    return 1;
                else if(o1<o2)
                    return -1;
                else
                    return 0;*/
//                return o1 - o2; // 默认升序
                return -(o1-o2);  // 降序
            }
        });
        System.out.println(Arrays.toString(arr));
    }

 static

修饰变量、内存机制

 修饰方法、内存机制

public class static_method {
    /**
        静态成员方法，归属于类，用类名或对象名都可以访问
     */
    public static int max(int a, int b){
        return a>b? a : b;
    }
    public static void main(String[] args) {
        //本类中的可以省略类名
        System.out.println(max(5,6));
        System.out.println(a.maxx(1,9));
    }
}
class a{
    public static int maxx(int a, int b){
        return a>b? a : b;
    }
}

 工具类

调用方便，代码复用

为什么工具类中的方法不用实例方法做?
@ 实例方法需要创建对象调用。

@ 此时用对象只是为了调用方法，这样只会浪费内存。

工具类定义时的其他要求:
@ 由于工具里面都是静态方法，直接用类名即可访问，因此，工具类无需创建对象（可以但对象浪费内存），建议将工具类的构造器进行私有。

public class static_toolUtil {
    private static_toolUtil(){}
    public static String VerifyCode(int n){
        String code = "";
        String data = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        Random r = new Random();
        for (int i = 0; i < n; i++) {
            int index = r.nextInt(data.length());
            code+=data.charAt(index);
        }
        return code;
    }
}

 用工具类类调用

代码块

static静态代码块

与类一起优先加载一次，自动触发执行，用于初始化静态资源

 构造代码块*

属于对象，调用构造器执行时，先执行这个，初始化实例资源

 单例设计模式

@ 可以保证系统中，应用该模式的这个类永远只有一个实例，一个类只能创建一个对象。
@ 例如任务管理器对象我们只需要一个就可以解决问题了，这样可以节省内存空间。

饿汉单例设计模式

在用类获取对象的时候，对象已经提前为你创建好了。

仅此处new一次 

  

 懒汉单例设计模式

在真正需要该对象的时候，才去创建一个对象(延迟加载对象)。

继承—extends

基本

java支持单继承，只能继承一个父类，可以多层继承，所有类都是Object的子类

1、子类是否可以继承父类的构造器?
@ 不可以的，子类有自己的构造器，父类构造器用于初始化父类对象。

2、子类是否可以继承父类的私有成员?

@ 可以的，但不能直接访问

3、子类是否可以继承父类的静态static成员?

@ 算是内存中共享的，不是共享的

4、多层继承访问成员变量方法

@ 满足就近原则，子类局部、成员、父类

5、如果子父类中，出现了重名的成员，会优先使用子类的，此时如果一定要在子类中使用父类的怎么办?

@ 可以通过super关键字，指定访问父类的成员。

方法重写

@  当子类需要父类的功能，但父类的该功能不完全满足自己的需求时。
@  子类可以重写父类中的方法。

@Override

---

 强行规定

构造器

子类全部构造器默认会先访问父类无参构造器

 

 this、super

不能递归调用

若写了super，则必须在第一行

枚举（理解意义）

信息的标志和信息的分类

 

抽象类

用abstract修饰抽象类和抽象方法，抽象方法只能有方法体，不能写具体内容

@ 一个类里如果有抽象方法，则这个类必须写成抽象类

@ 子类要完成某些行为，但是每个子类该行为的实现又不同，于是该父类就把该行为定义成抽象方法

@ 子类必须重写全部的抽象类

@ 抽象类中不一定有抽象方法，但抽象方法一定在抽象类里

@ 不能创建对象

 

模板方法模式

模板方法建议用final重写

接口

概念

接口可以继承extends多个接口

 实现

接口是用来实现的，实现接口的类叫做实现类（继承？？？）

和抽象一球样

可以继承多个

 @ 必须重写完接口的方法，不然也要定义成抽象类（万一特么接口里太多了怎么办）

 @ 接口不能创建对象

内部类*

静态

成员

局部

匿名

有时候没必要在定义一个子类，简化代码

public class annoy {
    public static void main(String[] args) {
        Animal a = new Animal() {
            @Override
            public void run() {
                System.out.println("666");
            }
        };
        a.run();
    }
}

abstract class Animal{
    public abstract void run();
}

---

自己感受 ，对象回调

public class annoy2 {
    public static void main(String[] args) {
        // 编译看左，运行看右
//        Swimming s = new Student();
        Swimming s = new Swimming() {
            @Override
            public void swim() {
                System.out.println("s游啊游游啊游");
            }
        };
        // 模板方法模式
        go(s);
        System.out.println("----------------");
        Swimming s2 = new Swimming() {
            @Override
            public void swim() {
                System.out.println("s2游啊游游啊游");
            }
        };
        go(s2);
        System.out.println("-----------------");
        go(new Swimming() {
            @Override
            public void swim() {
                System.out.println("内部类做参传递");
            }
        });
    }

/*class Student implements Swimming{
    @Override
    public void swim() {
        System.out.println("游啊游游啊游");
    }
}*/

interface Swimming{
    public abstract void swim();
}

写网盘用过的按钮都是这个

 API

Application Programming Interface，java写好的一些功能，可以直接使用

Object

java中的祖宗类，一切子类都可以直接使用的

equals

    public static void main(String[] args) {
        Integer a = new Integer(1);
        Integer b = new Integer(1);
        System.out.println(a.equals(b)); // true
        System.out.println(a == b);      // false
    }

 toString

Objects 

 StringBuilder

常用方法

 System

日期

LocalDate

public static void main(String[] args) {
        LocalDate localDate = LocalDate.now();
        // 2023-02-21
        System.out.println(localDate);
        // 2023/2/21
        System.out.println(localDate.getYear()+"/"+localDate.getMonthValue()+"/"+localDate.getDayOfMonth());
        // FEBRUARY
        System.out.println(localDate.getMonth());
        // 一年中的第几天
        System.out.println(localDate.getDayOfYear());
        // 21
        System.out.println(localDate.getDayOfMonth());
        // TUESDAY
        System.out.println(localDate.getDayOfWeek());
        //        -----------------------------------------------------
        LocalTime localTime = LocalTime.now();
        //        17:11:16.259725900
        System.out.println(localTime);
        //        17:11:16:259725900
        System.out.println(localTime.getHour()+":"+localTime.getMinute()+":"+localTime.getSecond()+":"+localTime.getNano());
        

    }

Instant

DataTimeFormat 

 间隔

包装类

@ java为了实现一切皆对象，为8种基本类型提供了对应的引用类型。
@ 后面的集合和泛型其实也只能支持包装类型，不支持基本数据类型。

 正则表达式

  

---

 

---

public static void main(String[] args) {
        String s = "小红sahdlabfhd小芳dsfhios小鸡";
        String[] arrs = s.split("\\w+");
        for (String arr : arrs) {
            System.out.print(arr);
        }

        String s1 = s.replaceAll("\\w+", "、");
        System.out.println(s1);
    }

Lambda

概念

 感受

public class Demo2 {
    public static void main(String[] args) {
        //        注意: Lambda表达式只能简化
        //      函数式接口的匿名内部类的写法
        //      形式
        Swiming s1 = new Swiming() {
            @Override
            public void swim() {
                System.out.println("swimswim");
            }
        };
        s1.swim();
        // ------------改成Lambda-------------
        Swiming s2 = ()->{
            System.out.println("swim2");
        };
        s2.swim();
        // ------------简化-------------
        // ------------没必要创建新对象时-------------
        go(new Swiming() {
            @Override
            public void swim() {
                System.out.println("jntm");
            }
        });
        // ------------简化-------------
        go(()->{
            System.out.println("swim3333");
        });


    }
    public static void go(Swiming s){
        System.out.println("---start---");
        s.swim();
        System.out.println("----end----");
    }
}

@FunctionalInterface
// 必须是函数式接口，只能有一个抽象方法
interface Swiming{
    void swim();
}

 几个简化案例

    public static void main(String[] args) {
        Integer[] arr = {5,9,36,23,256,84,6};
        /*Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });*/

        Arrays.sort(arr, (Integer o1, Integer o2)->{
            return o2-o1;
        });
        System.out.println(Arrays.toString(arr));


    }

继续简化

    public static void main(String[] args) {
        Integer[] arr = {5,9,36,23,256,84,6};
        /*
        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });
        */
        // -------↓↓↓↓↓-------
        /*Arrays.sort(arr, (Integer o1, Integer o2)->{
            return o2-o1;
        });
        System.out.println(Arrays.toString(arr));*/
        
        // -------------按钮案例------------------
        JFrame win = new JFrame("窗口");
        JButton jb = new JButton("点击");
        
        /*jb.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("点了一下~");
            }
        });*/
        // -------↓↓↓↓↓-------
        /*jb.addActionListener((ActionEvent e)->{
                    System.out.println("点了一下~");
                }
        );*/

        //1参数类型省略不写
        Arrays.sort(arr, (o1, o2)->{
            return o2-o1;
        });
        System.out.println(Arrays.toString(arr));
        //2一个参数，参数类型和（）都不写
        jb.addActionListener(e->{
                System.out.println("点了一下~");
            }
        );
        //3方法体只有一行，大括号和;不写
        jb.addActionListener(e->
                    System.out.println("点了一下~")
        );
        //4一行代码，大括号不写，若这是个return，必须！！省略return
        Arrays.sort(arr, (o1, o2)->
                o2-o1
        );
    }

集合

概念

数组：类型固定，大小固定

集合：大小不固定，类型也可不固定，适合增删操作

        集合中只能存储引用类型数据，如果要存储基本类型数据可以选用包装类。        

 Collection接口

    public static void main(String[] args) {
        //有序 重复 索引
        Collection a = new ArrayList();
        a.add(true);
        a.add(132);
        a.add(6);
        a.add(6);
        a.add("asd");
        a.add('a');
        System.out.println(a);//[true, 132, 6, 6, asd, a]
        //无序 不重复 无索引
        Collection a1 = new HashSet();
        a1.add(23);
        a1.add(23);
        a1.add("jkl");
        a1.add("opop");
        System.out.println(a1);//[opop, 23, jkl]

    }

泛型

遍历

迭代器

        Collection<String> a = new ArrayList<>();
        a.add("坤坤");
        a.add("凡凡");
        a.add("小强");
        a.add("老王");
        a.add("远哥");
        //当前集合的迭代器对象
        Iterator<String> it = a.iterator();
        while(it.hasNext()){
            System.out.println(it.next());//获得当前，又传递下一
        }

增强for

        Collection<String> a = new ArrayList<>();
        a.add("蔡徐坤");
        a.add("凡凡");
        a.add("小强");
        a.add("老王");
        a.add("远哥");
     
        for (String s : a) {
            System.out.println(s);
        }

在增强for中修改变量无意义，只是修改了中间变量的值

lambda表达式遍历

---

可以存放自定义元素类型，存放的是元素的地址 

List

 遍历同上，还有常规的for i<list.size();

ArrayList底层原理

@ ArrayList底层是基于数组实现的; 根据索引定位元素块，增删需要做元素的移位操作。
@ 第一次创建集合并添加第一个元素的时候，在底农创建一个默认长度为10的数组。

长度若超过容量，进行扩容，原大小+当前>>1=1.5倍原大小

LinkedList底层原理

 并发修改异常

就是边遍历边操作时会出现跳过的bug，迭代器、增强for、lambda，for（倒着可以）

用迭代器自己的删除方法可以避免，底层自-1

a.remove×

it.remove√

Set

Set<String> set = new HashSet<>();
Set<String> set1 = new LinkedHashSet<>();
Set<String> set2 = new TreeSet<>();

 HashSet无序底层原理

@ Hashset集合底层采取哈希表存储的数据。
@ 哈希表是一种对于增删改查数据性能都较好的结构。

 LinkedHashSet原理

 TreeSet原理

 

 可变参数（函数任意参数个数）

    public static void main(String[] args) {
        System.out.println(sum(2,8,9,3));
    }
    public static int sum(int...nums){
        int re = 0;
        for (int num : nums) {
            re += num;
        }
        return re;
    }

 集合工具类Collections

两种排序方法

 泛型深入

泛型类

泛型方法 

 泛型接口

 泛型通配符

@ ? 可以在“使用泛型”的时候代表一切类型。被ArrayList等进一步使用
@ ETKV是在定义泛型的时候使用的。可在定义时把ArrayList、LinkedList等大的作为E

Me：ETKV要被某个即将到来的唯一类型所替代，？通用

 

public class tongpeifu {
    public static void main(String[] args) {
        ArrayList<BMW> bmws = new ArrayList<>();
        bmws.add(new BMW());
        bmws.add(new BMW());
        bmws.add(new BMW());
        go(bmws);

        ArrayList<Dog> dogs = new ArrayList<>();
        dogs.add(new Dog());
        go(dogs);//error
    }

    public static void go(ArrayList<? extends Car> cars){

    }
}

class Car{}
class BMW extends Car{}
class BENZ extends Car{}
class Dog{}

 Map（键值对集合）

 

概念

Key：无序，不重复（唯一键）

Value：可以重复

常用API

 遍历

    Set<String> sets = shop.keySet();
        for (String key:sets){
            System.out.println(key+"=>"+shop.get(key));
        }

---

        Set<Map.Entry<String,Integer>> entry = shop.entrySet();
        for (Map.Entry<String,Integer> i:entry){
            System.out.println(i.getKey()+"=>"+i.getValue());
        }

---

        shop.forEach(new BiConsumer<String, Integer>() {
            @Override
            public void accept(String s, Integer integer) {
                System.out.println(s+"=>"+integer);
            }
        });

HashMap

 实际上: Set系列集合的底层就是Map实现的，只是Set集合中的元素只要键数据，不要值数据而已。

 

LinkedHashMap

TreeMap

---