java核心技术(卷一)笔记

重新打一遍基础，查漏补缺

字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
package com.xiaoyuyu.stringTest;

import org.junit.jupiter.api.Test;

/**
 * @Description: java类作用描述
 * @Author: Xiaoyuyu
 * @CreateDate: 2021/10/9 8:16 下午
 */
public class test1 {

    public static void main(String[] args) {
        System.out.println(1);
        // String 常用api查阅 : http://docs.oracle.com/javase/9/docs/api
    }

    @Test
    public void testEqual() {
        // == 与 equal的区别
        String a = "hello";
        String b = "Hello";
        String c = "hello";
        String d = new String("hello");

        System.out.println(a.equals(c));
        // true
        // 值相同

        System.out.println(a==c);
        // true
        // 值相同，且地址相同，这里涉及到声明字符串大部分情况下会从常量池里面找，暂时不展开

        System.out.println(a.equals(d));
        // true
        // 值依然相同

        System.out.println(a==d);
        // false
        // 地址已经不相同了，是new String新在堆上开辟的，不是常量池中获取的

        System.out.println(a.equalsIgnoreCase(b));
        // true
        // 忽略大小写的比较值方式，每次看书都有新收获
    }
}

类概念

requireNonNull

一个没接触过的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package com.xiaoyuyu.classTest;

import org.junit.jupiter.api.Test;

import java.time.LocalDate;
import java.util.Objects;

/**
 * @Description: java类作用描述
 * @Author: Xiaoyuyu
 * @CreateDate: 2021/10/9 8:52 下午
 */
public class test1 {

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

    @Test
    public void testNull() {
        LocalDate birthday = null;
        try {
            Objects.requireNonNull(birthday,"No Null!");
        } catch (Exception e) {
            System.out.println(e);
            // java.lang.NullPointerException: No Null!
        }

        // Objects.requireNonNullElse(birthday,"Null");
        // 返回Null
        // jdk9以后的方法，还蛮好用的
    }
}

访问权限

初始化块/静态代码块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
package com.xiaoyuyu.classTest;

/**
 * @Description: java类作用描述
 * @Author: Xiaoyuyu
 * @CreateDate: 2021/10/9 9:13 下午
 */
public class test2 {

    public String name;

    // static initialization block
    // 静态代码块，只在第一次调用这个类的时候调用
    static {
        System.out.println("static");
    }

    // object initialization block
    // 初始化块，每次执行构造方法时都先执行
    {
        System.out.println("init");
    }

    public test2() {
    }

    public test2(String name) {
        this.name = name;
        System.out.println(name);
    }

    public static void main(String[] args) {

        test2 student1 = new test2();
        test2 student2 = new test2("xiaoyuyu");
        /*static
        init
        init
        xiaoyuyu*/
    }
}

文档注释

平时注释写的不好，需要看一下

继承

多态常犯的错误

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
package com.xiaoyuyu.classTest;

import org.junit.jupiter.api.Test;

/**
 * @Description: java类作用描述
 * @Author: Xiaoyuyu
 * @CreateDate: 2021/10/9 9:50 下午
 */
public class test3 {

    static class Employee {

        public int salary;

        public Employee(int salary) {
            this.salary = salary;
        }

        public Employee() {
        }

        public void setSalary(int salary) {
            this.salary = salary;
        }
    }

    static class Manager extends Employee {

        public Manager() {
        }

        public void setBonus(int salary) {
            this.salary = salary;
        }
    }

    public static void main(String[] args) {

        System.out.println(1);
    }

    @Test
    public void multiClassError() {
        Manager boss = new Manager();
        Employee[] staff = new Employee[3];
        staff[0] = boss;
        boss.setBonus(5000);
        // staff[0].setBonus(5000); // error, 因为整个数组每个元素类型设定是Employee，会直接编译错误
        // Manager m = staff[0]; // error，还是类型问题，Employee类型的元素不能赋值给Manager类型
        // 使用强制转换
        if (staff[0] instanceof Manager) {
            boss = (Manager) staff[0];
        }
    }
}

final

1.final关键字修饰类体现在该类不能被继承

2.final关键字修饰成员方法体现在该方法不能被重写但可以被继承。

3.final关键字修饰成员变量体现在该变量必须初始化且不能改变。

参数数量可变

没想到发现一个小tips，我以为java是不允许人为制造可变参的函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package com.xiaoyuyu.classTest;

/**
 * @Description: java类作用描述
 * @Author: Xiaoyuyu
 * @CreateDate: 2021/10/9 10:31 下午
 */
public class test4 {

    public static double max(double... values) {
        double largest = Double.MIN_VALUE;
        for (double elem : values) {
            if (elem > largest) {
                largest = elem;
            }
        }
        return largest;
    }

    public static void main(String[] args) {

        double ans = max(1,31,-100,31.2,100.5);
        System.out.println(ans);
    }
}

枚举类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package com.xiaoyuyu.classTest;

/**
 * @Description: java类作用描述
 * @Author: Xiaoyuyu
 * @CreateDate: 2021/10/9 10:39 下午
 */
public enum  test5 {
    SMALL("S"),MEDIUM("M"),LARGE("L");

    public String size;

    // 枚举类的构造器总是私有的，可以省略private
    test5(String s) {this.size = s;}

    public String getSize() {
        return size;
    }

    public static void main(String[] args) {

        // 因为本身是Enum的子类，所以继承了他的方法，介绍一些常用的方法

        // toString，返回字符串LARGE
        System.out.println(test5.LARGE.toString());

        // toString的逆静态方法，返回Size.Large
        test5 s = Enum.valueOf(test5.class,"LARGE");

        // 静态方法values，返回枚举类全部元素
        test5[] values = test5.values();

        // ordinal方法返回声明中枚举常量的位置
        System.out.println(test5.MEDIUM.ordinal()); // 1
    }
}

反射

public 和 private的所有属性和方法都是可以获取的，区别就是要不要加Declared

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
/**
 * @Description: java反射
 * @Author: Xiaoyuyu
 * @CreateDate: 2021/5/11 8:42 上午
 */

package Reflect_Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

class Person {
    private String name;
    private int age;

    public Person() {
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    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 class Reflect_Test {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
        // 四种获取class的方法
        Person p = new Person("xiaoyuyu",23);
        Class c1 = Person.class;
        System.out.println("方法一 : 调用运行时类的.class属性: "+c1.toString());
        Class c2 = p.getClass();
        System.out.println("方法二 : 通过运行时类的对象，调用getClass()方法: "+c2.toString());
        Class c3 = Class.forName("Reflect_Test.Person");
        System.out.println("方法三 : 调用Class的静态方法forName: "+c3.toString());
        Class c4 = Person.class.getClassLoader().loadClass("Reflect_Test.Person");
        System.out.println("方法四 ：通过类的加载器: "+c4.toString());

        System.out.println();
        // 获取Class中的构造函数
        System.out.println("getConstructors为获取类的public的构造方法 ");
        Constructor[] constructors1 = c1.getConstructors();
        for(int i=0;i<constructors1.length;i++){
            System.out.println("constructors ["+i+"] :"+constructors1[i]);
        }

        System.out.println();
        // 获取Class中的构造函数
        // 调用指定的构造器创建运行时类的对象
        // 我们指定public类型的构造方法Person(String name, int age)来创建对象
        Class<? extends Object> c5 = Person.class;
        Constructor constructor = c5.getConstructor(String.class,int.class);
        Person person = (Person) constructor.newInstance("louwin",24);
        System.out.println("调用指定的构造器(public)创建运行时类的对象 --person: "+person.toString());

        System.out.println();
        // 获取Class中全部Method
        //getMethods此方法为获取类的public方法，包括父类的public方法
        System.out.println("getMethods此方法为获取类的public方法，包括父类的public方法 ");
        Method[] method1 = c5.getMethods();
        for(int i=0;i<method1.length;i++) {
            System.out.println("method1 [" + i + "] :" + method1[i]);
        }

        System.out.println();
        System.out.println("调用方法public setAge");
        // 调用方法public setAge
        Method setAge = c5.getMethod("setAge", int.class);
        setAge.setAccessible(true);
        System.out.println("修改前的person:"+person.toString());
        setAge.invoke(person, 100);
        System.out.println("修改后的person:"+person.toString());

        System.out.println();
        // 获取Class类中Field
        System.out.println("获取Class类中Field");
        System.out.println("getFields此方法为获取类的public属性，包括父类的public属性 ");
        Field[] field1 = c5.getFields();
        for(int i=0;i<field1.length;i++){
            System.out.println("field1 ["+i+"] :"+field1[i]);
        }

        System.out.println("getDeclaredFields此方法为获取类的本身声明的所有属性，包括private ");
        Field[] field2 = c5.getDeclaredFields();
        for(int i=0;i<field2.length;i++){
            System.out.println("field2 ["+i+"] :"+field2[i]);
        }

        // 对Field进行处理
        System.out.println();
        System.out.println("对Field进行处理");
        System.out.println("对public类型的属性进行操作，以类本身的private属性name为例");
        Field f1 = c5.getDeclaredField("name");
        f1.setAccessible(true);
        String name = (String)f1.get(person);
        System.out.println("修改前person对象name:"+name);

        f1.set(person, "daWa");
        name = (String)f1.get(person);
        System.out.println("修改后person对象的name:"+name);
    }
}

接口

解决默认方法冲突

实现两个接口时，指定调用的是哪个接口的方法即可

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package com.xiaoyuyu.interfaceTest;

/**
 * @Description: java类作用描述
 * @Author: Xiaoyuyu
 * @CreateDate: 2021/10/11 12:10 下午
 */
public class test1 {

    interface Person {
        default String getName() {
            return "person";
        }
    }

    interface Named {
        default String getName() {
            return "named";
        }
    }

    static class Student implements Named,Person {

        @Override
        public String getName() {
            return Person.super.getName();
        }
    }

    public static void main(String[] args) {

        Student student = new Student();
        System.out.println(student.getName()); // person
    }
}

这里之所以要加super的原因很难解释，但是如果不加super，那么显然这个方法需要时一个静态的方法，加了super，可以表示这个方法来自已识别的超级的方法。

如果是同事继承类，并实现了一个接口，则有冲突的方法自动使用类的，这就是类优先规则

lambda表达式

以下是lambda表达式的重要特征:

  • 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
  • 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
  • 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
  • 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定表达式返回了一个数值。
1
(int a, int b) -> { return a * b; };

函数式接口

对于只有一个抽象方法的接口，需要这种借口的对象时，就可以提供一个lambda表达式。这种接口称为函数式接口。

可能是我水平不够，我个人觉得scala里面使用函数式编程我可以接受，java我还是不习惯。

异常、断言、日志

异常分类

在java中，异常对象都是派生于Throwable类的一个类实例，但在下一层，分解为两个分支：Error,Exception。

Error的话除了通知用户，退出程序，无能为力。Exception又可以分解为：IOException和RuntimeException。

主要还是try catch finally

断言

断言机制允许在测试期间向代码插入一些检查，而在生产代码中会自动删除这些检查。

1
2
assert condition;
assert condition : expression;

这两个语句都会计算条件，如果结果为false，则抛出一个AssertionErroe异常。在第二个语句中，表达式将传入AssertionError对象的构造器，并转换成一个消息字符串。

日志

基本日志

1
Logger.getGlobal().info("a log");

高级日志

一个专业的应用程序中，肯定不能把所有日志都记录到一个全局日志记录器中，可以定义自己的日志记录器。

1
private static final Logger myLogger = Logger.getLogger("com.xiaoyuyu.myAPP");

泛型程序设计

泛型方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
package com.xiaoyuyu.genericTest;

import java.util.ArrayList;
import java.util.List;

/**
 * @Description: java类作用描述
 * @Author: Xiaoyuyu
 * @CreateDate: 2021/10/17 1:31 下午
 */
public class test1 {

    static class ArrayAlg {

        // 普通类中泛型方法
        // 类型变量放在修饰符的后面，并放在返回类型的前面
        public static <T> T getMiddle(T... a) {
            return a[a.length/2];
        }

        // 类型变量的限定
        // 类或方法需要对类型变量加以约束
        // <T extends BoundingType> 表示T应该是限定类型（BoundingType）的子类型
        // T和限定类型可以是类，也可以是接口
        // T extends BoundingType & Serializable
        // 根据需要可以拥有多个接口超类型，但只能有一个限定类型是类
        public static <T extends Comparable> T min(T[] a) {
            if (a == null || a.length == 0) return null;
            T smallest = a[0];
            for (int i = 1; i < a.length; i++) {
                if (smallest.compareTo(a[i]) > 0) smallest = a[i];
            }
            return smallest;
        }
    }

    public static void main(String[] args) {

        // 调用泛型方法
        String middle = ArrayAlg.<String>getMiddle("John","Q","Public");
        System.out.println(middle); // Q

        // 不能用基本类型代替类型参数，不能用int，只能用Integer
        Integer[] ints = new Integer[]{14,3,11,7};
        int smallest = ArrayAlg.<Integer>min(ints);
        System.out.println(smallest);   // 3

        // 运行时类型查询只适用于原始类型
        List<String> list = new ArrayList<>();
        List<Integer> list2 = new ArrayList<>();
        System.out.println(list.getClass()==list2.getClass());  // true，原始类型都是List.class，擦除了泛型
    }
}

还有一些不合法的操作

1
2
3
4
5
参数：Class<T> cl
// error
first = T.class.getConstructor().newInstance;
// solution
first = cl.getConstructor().newInstance;

不能再静态字段或者方法中引用类型变量

1
private static t singleInstance;	// ERROR

即不能抛出也不能捕获泛型类的对象

1
catch (T e) // ERROR

通配符<? extends T> 和 <? super T>

这问题可太经典了，白菜继承了蔬菜类，装着白菜的盘子不是装着蔬菜的盘子的子类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
package wildcardCharacter;

import java.util.ArrayList;
import java.util.List;

/**
 * @Description: <? extends Father>
 * @Author: Xiaoyuyu
 * @CreateDate: 2021/8/24 10:32 上午
 */
public class questionExtends {

    public static void main(String[] args) {
        List<? extends Father> list = new ArrayList<Father>() {
            {
                add(new Son("xiaoyuyu"));
                add(new Father("louwin"));
            }
        };
        // ? extends 只能读取，不能存储，但可以初始化的时候直接放入元素
      	// ? super相反，能存入，但读取的类型不强制转换的情况下只能是Object类型
        Father o1 = list.get(0);
        Object o2 = list.get(1);
        Son o3 = (Son) list.get(0);
        System.out.println(o1.toString());
        System.out.println(o2.toString());
        System.out.println(o3.toString());
    }
}

class Father {
    public String name;

    public Father(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Father{" +
                "name='" + name + '\'' +
                '}';
    }
}

class Son extends Father {

    public Son(String name) {
        super(name);
    }
}

并发

每个进程都拥有自己的一整套变量，而线程则共享数据，共享变量使得线程之间的通信比进程之间的通信更有效。

常见的一些基础在这里就不记录了，主要是翻书的时候查漏补缺时记下的。

本文作者： xiaoyuyu
本文链接： http://woaixiaoyuyu.github.io/2021/10/17/java%E6%A0%B8%E5%BF%83%E6%8A%80%E6%9C%AF(%E5%8D%B7%E4%B8%80)%E7%AC%94%E8%AE%B0/
版权声明： 本作品采用 知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议 进行许可。转载请注明出处！
赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码
本站总访问量次 本站访客数人

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

记录成长的点滴<br><br>涉猎颇广的信息技术爱好者<br>希望未来的xiaoyuyu<br>可以成为优秀的工程师