Java 点滴

作者: 内蒙小猿 | 来源:发表于2022-06-10 10:49 被阅读0次

[toc]

== 和 equals 的对比

== 是一个比较运算符

1、== ：既可以判断类型，又可以判断引用类型
2、== ：判断基本类型，判断的是值是否相等
3、== ：如果是引用类型，判断的是地址是否相等，即判定是不是同一个对象

equals

1、equals ：是object 类中的方法，只能判断引用类型，
2、equals ：默认判断的是地址是否相等，子类中往往重写该方法(public boolean equals(object obj) ) 用于判断内容是否相等，

Java hashCode

1、提高具有哈希结构的效率
2、两个引用，如果指向的是同一个对象，则哈希值肯定是一样的！
3、两个引用，如果指向的是不同对象，则哈希值是不一样的
4、哈希值主要根据地址号来的！，不能完全将哈希值等价于地址
5、集合中hashCode 按需重写

Java 的动态绑定机制

B 是 A 的子类， A a = new B()
a 在编译类型是 A （等号左边），运行类型是 B （等号右边）

视频地址

1、当调用对象的方法的时候，该方法会和该对象的内存地址进行绑定
2、当调用对象属性时，没有动态绑定机制，哪里有声明，哪里使用

接口

implements 实现接口
extends 继承

1、JDK 7.0 以前，接口里的所有方法都没有方法体，即都是抽象方法
2、JDK 8.0 后，接口可以有静态方法，默认方法，也就是说接口中可以有方法的具体实现（default 关键字修饰）
3、一个类可以实现多接口 implements A ,B
4、接口中的属性，只能是final的。而且是 public static final
5、接口中属性的访问形式 : 接口明. 属性名
6、接口不能继承其他类，但是可以继承多个别的接口
7、接口的修饰符只能是 public 和默认，这点和类的修饰符是一样的

代码块

1、static 代码块也叫静态代码块，作用就是对类进行初始化，而且他随着类的加载而执行，并且只会执行一次。如果是普通代码块，没创建一个对象，就执行一次。
2、类什么时候被加载【需要背】

1、创建对象实例时(new)
2、创建子类对象实例，父类也会被加载
3、使用类的静态成员时(静态属性、静态方法)

3、普通代码块，在创建累的实例时，会被隐式调用。被创建一次，就会被调用一次。如果只是使用类的静态成员时，普通代码块并不会被调用
note:
1、staitc 代码块是在类加载时执行，且只会执行一次
2、普通代码块是在创建对象时调用的，创建一次就会调用一次
3、类加载的三种情况，需要记住！！！

创建一个类时，在一个类调用的顺序是：（重点，难点）

1、调用静态代码块和静态属性初始化(注意：静态代码块和静态属性初始化调用的优先级是一样的，如果有多个静态代码块和多个静态变量初始化，则按着他们的定义顺序进行调用)

2、调用普通代码块和普通属性初始化方法(注意：普通代码块和蒲绒属性调用的优先级是一样的，按定义顺序调用)

3、调用构造方法

创建一个子类(继承关系),他们的静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序如下：

1、父类的静态代码块和静态属性，按顺序执行
2、子类的静态代码块和静态属性，按顺序执行
3、父类的普通代码块和普通类属性，按执行顺序执行
4、父类的构造方法
5、子类的普通代码块和普通类属性，按顺序执行
6、子类的构造方法

静态、非静态方法调用

静态代码块只能直接调用静态成员(静态属性和静态方法)，普通代码块可以调用任意成员

内部类

一个类内部又完整嵌套了另一个类结构。被嵌套的类称为内部类，嵌套其他类的类称为外部类。使我们类的第五大成员【五大成员：
属性、方法、构造器、代码块、内部类】，内部类最大特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系

class Outer { // 外部类
    class Inner{ // 内部类
    }
}

class Other{  // 其他类
}

内部类分类

定义在外部类局部位置上(比如方法上)

package com.zhao.smallchange;

public class Outer {

    private int age = 23;

    public static void main(String[] args) {
        new Outer().innerAction();
    }

    public void innerAction(){
        class innerClass{
            private int age = 12;

            public void sayAge(){
                System.out.println("内部类age:" + age + "外部类age:" + Outer.this.age );
            }
        }

        innerClass innerClass = new innerClass();
        innerClass.sayAge();

    }
}

1、局部内部类（有类名）
1、局部内部类是定义在外部类的局部位置，通常在方法、代码块中
2、可以直接访问外部类的多有成员，包含私有的
3、不能添加访问修饰符，但是可以使用final修饰
4、作用域：仅仅在定义它的方法或者代码块中
5、局部内部类可以直接访问外部类的成员，比如方法和属性
6、外部类在方法中，可以创建内部类对象，让后调用方法即可
7、外部其他类 不能访问 局部内部类 (因为内部类地位是一个局部变量)
8、如果外部类和局部内部类成员变量重名时，默认遵循就近原则，如果想访问外部类的成员变量，则可以使用 (外部类名.this.成员) 去访问

2、匿名内部类（没有类名，重点！！）

new 类或者接口(参数列表){
    类的相关实现 
};

// 实际使用

package com.zhao.smallchange;

public class Outer {

    public static void main(String[] args) {
        new Outer().innerAction(new OuterInterface() {
            @Override
            public void sayHello() {
                System.out.println("我是匿名内部类");
            }
        });
    }

    public void innerAction(OuterInterface subInterface){
        subInterface.sayHello();
    }


}

interface OuterInterface{
    public void sayHello();
}

定义在外部类的成员位置上

package com.zhao.smallchange;

public class Outer {

    private int n1 = 10;
    public String name = "张三";

    public static void main(String[] args) {
        new Outer().t1();
    }


    class InnerClass{
        public void say(){
            System.out.println("n1 = " + n1 + " name =" + name);
        }
    }

    public void t1(){
        InnerClass innerClass = new InnerClass();
        innerClass.say();
    }

}

1、成员内部类（没有static修饰）

1、可以直接访问外部类的成员变量，包含私有
2、可以添加任意访问修饰符( public、protected、默认、private )，因为它的地位就是一个成员。
3、作用域：和外部类的其他成员一样，为整个类
4、成员内部类 --> 访问外部类成员，直接访问
5、外部类 --> 访问内部类，创建内部类对象，并访问

6、其他外部类 --> 访问 --> 成员内部类

6.1、第一种方式

  public static void main(String[] args) {
     InnerClass innerClass = new Outer().new InnerClass();
 }

6.2、第二种方式，通过一个方法返回内部类对象

 public static void main(String[] args) {
     InnerClass innerClass1 = new Outer().getInnerClass();
 }
 
 public InnerClass getInnerClass(){
     return new InnerClass();
 }

-7、如果内部类成员变量和外部类成员变量冲突，外部类还是外部类.this.成员变量

2、静态内部类（使用static修饰）

class Outer10{

    private int n1 = 10;
    private static String name = "张三";

    static class Inner10{
        
    }

}

1、放在外部类成员位置
2、使用 static 修饰
3、可以访问外部类的所有成员变量，包含私有的，但不能直接访问非静态变量
4、可以添加任意访问修饰符 (public、protected、默认、private)，但是不能直接访问非静态成员变量

// 第一种： 对象调用
package com.zhao.smallchange;

public class StaticInnerClass01 {

    public static void main(String[] args) {

        Outer10.Inner10 inner10 = new Outer10.Inner10();
    }

}

class Outer10{

    private int n1 = 10;
    private static String name = "张三";

    static class Inner10{

    }

}

// 第二种： 普通方法暴露
package com.zhao.smallchange;

public class StaticInnerClass01 {

    public static void main(String[] args) {

        Outer10.Inner10 staticInnerClass = new Outer10().getStaticInnerClass();

    }

}

class Outer10{

    private int n1 = 10;
    private static String name = "张三";

    static class Inner10{

    }

    public Inner10 getStaticInnerClass(){
        return new Inner10();
    }

}

// 第三种：static 方法
package com.zhao.smallchange;

public class StaticInnerClass01 {

    public static void main(String[] args) {

        Outer10.Inner10 staticInnerClass = Outer10.getStaticInnerClass();

    }

}

class Outer10{

    private int n1 = 10;
    private static String name = "张三";

    static class Inner10{

    }

    public static Inner10 getStaticInnerClass(){
        return new Inner10();
    }

}

5、作用域整个类
6、如果外部类和静态内部类的成员重名是，静态内部类访问的时候，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类.成员）去访问

String、StringBuilder、StringBuffer 选择

1、如果字符串存在大量的修改操作，一般使用StringBuilder 和 StringBuffer
2、如果字符串存在大量的修改操作，并在单线程情况下，使用StringBuilder
3、如果字符串存在大量的修改操作，并在多线程情况下，使用StringBuffer
4、如果我们字符串很少修改，被多个对象引用，使用String。比如配置信息

random 随机数

返回的是 0 <= x < 1 之间的随机小数

1、[2 7] 随机整数 (int)(a + Math.random() * (b - a + 1))
2、[2 7) 随机整数 (int)(a + Math.random() * (b - a))

    public static void main(String[] args) {
        // 思考：请写出获取 a, b 之间的一个随机整数，a = 2 b = 7

        // 1、 [0 10) 随机数
        System.out.println("=========[0 10) 随机数===========");
        for (int i = 0; i < 10; i++) {
            System.out.println(10 * Math.random());
        }

        // 2、 [0 10) 随机整数
        System.out.println("=========[0 10) 随机整数===========");
        for (int i = 0; i < 10; i++) {
            double random = Math.random();
            System.out.println(10 * random);
            System.out.println((int)(10 * random));
        }

        // 3、[2 12) 随机整数
        System.out.println("=========[2 12) 随机整数===========");
        for (int i = 0; i < 10; i++) {
            double random = Math.random();
            System.out.println(10 * random + 2);
            System.out.println((int)((12 - 2) * random + 2));
        }

        // 4、[2 7) 随机整数
        System.out.println("=========[2 7) 随机整数===========");
        for (int i = 0; i < 10; i++) {
            double random = Math.random();
            System.out.println(5 * random + 2);
            System.out.println((int)((7 - 2) * random + 2));
        }

        // 5、[2 7]随机整数 ==  [2 8)随机整数
        System.out.println("=========[2 7] 随机整数===========");
        for (int i = 0; i < 10; i++) {
            double random = Math.random();
            System.out.println((8 - 2) * random + 2);
            System.out.println((int)((1 + (7 - 2)) * random + 2));
        }

集合实现类的选择

1、一组对象：Collection 接口
- 允许重复：List
  增删多：LinkedList 底层维护了一个双向链表
  改查多：ArrayList 底层维护 Object类型的可变数组
- 不允许重复：Set
  无序：HashSet 底层是HashMap，维护了一个哈希表即(数组 + 链表 + 红黑树)
  排序：TreeSet
  插入和取出顺序一致：LinkedHashSet，维护数组 + 双向链表
2、一组键值对
- 1、键无序：HashMap 底层是：哈希表 jdk7: 数组 + 链表 jdk8：数组 + 链表 + 红黑树
- 2、键排序：TreeMap
- 3、键插入和取出顺序一致：LinkedHashMap
- 4、读取文件 Properties

Thread 和 Runnable

1、从Java 设计上来看，通过继承Thread或者实现Runnable 接口来创建线程本质上是没有区别的，Thread 类本身就实现了 Runnable 接口
2、实现Runnable 接口方式更加适合多个线程共享一个资源的情况，并且避免了继承的限制

package com.zhao.learn01;

public class Learn {

    public static void main(String[] args) {

        T3 t3 = new T3();

        Thread thread1 = new Thread(t3);
        Thread thread2 = new Thread(t3);

        thread1.start();
        thread2.start();

    }

}


class T3 implements Runnable{

    @Override
    public void run() {
        // 进行线程操作

    }
}

线程常用方法

1、setName ：设置线程名称，使之与参数name相同
2、getName：返回该线程的名称
3、start：使该线程开始执行；java虚拟机底层调用线程 start0 方法
4、run：调用线程对象 run 方法
5、setPriority：更改线程优先级
6、getPrority：获取线程优先级
7、sleep：在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)
8、interrupt ：中断线程
9、yield：线程的礼让，让出CPU让其他线程执行。但是礼让时间不确定，所以也不确定成功
10、join：线程的插队，插队线程一旦插队成功，则肯定先执行完插入线程的所有任务

note：

1、start 底层会创建新的线程，并调用run，run就是一个简单的方法调用，不会启动新的线程
2、线程优先级范围
3、interrupt，中断线程，但没有真正的结束线程。所以一般用于中断正在休眠的线程
4、sleep 线程的静态方法，使当前线程休眠

Java 点滴

== 和 equals 的对比

== 是一个比较运算符

equals

Java hashCode

Java 的动态绑定机制

接口

代码块

创建一个类时，在一个类调用的顺序是：（重点，难点）

创建一个子类(继承关系),他们的静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序如下：

静态、非静态方法调用

内部类

内部类分类

定义在外部类局部位置上(比如方法上)

定义在外部类的成员位置上

String、StringBuilder、StringBuffer 选择

random 随机数

集合实现类的选择

Thread 和 Runnable

线程常用方法

note：

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Java 点滴

== 和 equals 的对比

== 是一个比较运算符

equals

Java hashCode

Java 的动态绑定机制

接口

代码块

创建一个类时，在一个类 调用的顺序是：（重点，难点）

创建一个子类(继承关系),他们的静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序如下：

静态、非静态 方法调用

内部类

内部类分类

定义在外部类局部位置上(比如方法上)

定义在外部类的成员位置上

String、StringBuilder、StringBuffer 选择

random 随机数

集合实现类的选择

Thread 和 Runnable

线程常用方法

note：

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

创建一个类时，在一个类调用的顺序是：（重点，难点）

静态、非静态方法调用