Java复习总结笔记（上）

目录

前言

一、基础语法

1.1 Java名词

1.2 Java关键字

1.3 基本数据类型（4类8种）

（1）整数类型

（2）浮点类型

（3）字符型

（4）布尔型

1.4 基本数据类型包装类

（1）对应关系

（2）装箱与拆箱

（3）一些包装类方法

1.5 引用数据类型

（1）String类

（2）接口

（3）数组

二、流程控制

2.1 顺序结构

2.2 选择结构

（1）if语句

（2）switch语句

2.3 循环结构

（1）while 和do while

（2）for和增强for

2.4 break、continue、return

三、面向对象

3.1 构造方法、代码块、抽象类和栈堆内存

（1）声明对象和Lombok使用

（2）代码块

（3）抽象类

（4）栈堆内存

3.2 继承、封装、多态

（1）继承

（2）封装

（3）多态

3.3 内部类

四、异常处理

4.1 异常类关系

 4.2 异常处理

（1）捕获异常

（2）抛出异常

（3）throws和throw

 4.3 自定义异常

（1）继承Exception

（2）编写构造方法，传入异常信息

（3）调用时通过throw向外抛出异常

总结

对Java部分知识体系进行复习总结，没事可以看看。

官网：Java 软件 | Oracle 中国

JDK：Java开发环境，包括编译（Javac）、解释（Java）、打包（Jar）等工具。

JRE：Java运行环境，由Java的虚拟机和Java的API构成。

JVM：Java虚拟机。

字节码本质是一种标准化可移植的二进制格式。格式为.Class。一个Java程序可由不同的.Class文件构成。

其中goto、const在Java中没有任何意义。

strictfp用来确保浮点数运算的准确性，例如：

public strictfp class Test1 {
    public void sumab(float a,double b){
        double sum = a + b;
        System.out.println(sum);
    }
 
    @Test
    public void test(){
        float a = 0.123f;
        double b = 0.0123d;
        new Test().sumab(a,b);
    }
 }

instanceof用于测试它左边的对象是否是它右边的类的实例，例如：

public class Test1 {
    @Test
    public void test(){
        int[] array = {1,2,3,4,5,6};
        System.out.println(array instanceof int[]);
    }
}

transient只能用来修饰成员变量，被transient修饰的成员变量不参与序列化，静态成员变量也不能被序列化，不管有没有transient关键字。

public class Test1 {       
    @Test
    public void test(){
        // 装箱
        Integer intObj = new Integer(10);
        // 拆箱
        int result = intObj.intValue();
        System.out.println(result+result);
        // 自动装箱
        Integer intObj2 = 20;
        // 自动拆箱
        int result2 = intObj2;
        System.out.println(result2+result2);
    }
}

public class Test1 {       
    @Test
    public void test(){
        String a = "123";
		//将字符串转换成整型
		int b = Integer.parseInt(a);
		//将整型变为字符串
		String c = String.valueOf(b);
		System.out.println(a.getClass().getName());
		System.out.println(c.getClass().getName());
    }
}

包装类对象之间值比较使用equals()方法。

查找字符串的方法indexOf()、lastIndexOf()。

判定字符串一致的方法为equals()和==：equals()是比较值是否相等，==是否引用同一位置。

String、StringBuffer、StringBuilder：String是只读字符串，一旦被初始化，就不能改变，每次改变都会生成新的字符串，浪费内存；StringBuffer内容可改变，不生成新对象，节约内存，线程安全；StringBuilder *** 作效率比StringBuffer高，非线程安全。

接口中有常量、抽象方法，也有非抽象方法，接口中定义的量为常量，无构造方法，例如：

public interface TestInterface {
    public static final int num =  1;
    public abstract void aaa();
    public abstract void bbb(int num);
    public default void  ccc(){
        System.out.println("ccc");
    }
}

接口必须有子类，子类可同时实现多接口，例如：

interface aaa{
    public abstract void print();
}
interface bbb{
    public abstract void get();
}
class ccc implements aaa,bbb{
    public void print(){
        System.out.println("aaa");
    }
    public void get(){
        System.out.println("bbb");
    }
}

一句话：单继承，多实现

数组初始化，例如：

public class Test1 {
    @Test
    public void test(){
        int[] array1 = {1,2};
        int[] array2 = new int[]{1,2};
        int[] array3 = new int[2];
        array3[1] = 1;
        array3[2] = 2;
        int[][] array4 = {{1,2},{1,2,3},{1,2}};
    }
}

数组遍历方式，例如：

public class Test1 {
    int[] array1 = {1,2};
    int[][] array2 = {{1,2},{1,2,3}};
    @Test
    public void test(){
        for (int i = 0; i < array1.length; i++) {
            System.out.println(array1[i]);
        }
        for (int a:array1) {
            System.out.println(a);
        }
        for (int i = 0; i < array2.length; i++) {
            for (int j = 0; j < array2[i].length; j++) {
                System.out.print(array2[i][j]);
            }
            System.out.println();
        }
        for (int[] a:array2) {
            for (int b:a) {
                System.out.print(b);
            }
            System.out.println();
        }
    }
}

冒泡排序法，例如：

public class Test1 {
    int[] array1 = {1,2,1,6,2,3,5,4,3};
    @Test
    public void test(){
        for (int i = 0; i < array1.length; i++) {
            for (int j = i+1; j < array1.length; j++) {
                if (array1[i]

public class Test1 {
    int[] array1 = {1,2,1,6,2,3,5,4,3};
    int[] array2 = {1,2,3,4,5,6};
    @Test
    public void test() {
        Arrays.sort(array1);
        //数组的遍历
        System.out.print(Arrays.toString(array1));
        //二分法查找有序数组    
        System.out.println(Arrays.binarySearch(array1,1));
        System.out.println(Arrays.equals(array1,array2));
        //数组复制
        int[] array3 = Arrays.copyOf(array2,3);
        //数组全部填充10
        Arrays.fill(array3,10);
        System.out.print(Arrays.toString(array3));
    }
}

public class Test1 {
    int a = 1;
    @Test
    public void test1() {
        if(a>0){
            System.out.println("a>0");
        }else if (a<0){
            System.out.println("a<0");
        }else {
            System.out.println("a=0");
        }
    }
    @Test
    public void test2(){
        if(a>0){
            System.out.println("a>0");
        }
        if(a<0){
            System.out.println("a>0");
        }
        if(a==0){
            System.out.println("a=0");
        }
    }
}

public class Test1 {
    int a = 2;
    @Test
    public void test() {
        switch (a){
            case 1:
                System.out.println("1");
                break;
            case 2:
                System.out.println("2");
                break;
            default:
                System.out.println("未知");
                break;
        }
    }
}

public class Test1 {
    int a = 2;
    @Test
    public void test() {
        while(a<3){
            a+=1;
        }
        System.out.println(a);
        do{
            a+=1;
        }while (a<10);
        System.out.println(a);
    }
}

        
            org.projectlombok
            lombok
            1.18.12
            provided
        

public interface PhoneInterface {
    public void listen();
}

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Phone {
    private String brand;
    private int price;

    public void listen(){
        System.out.println(brand+"手机听歌");
    }
}

public class Test1 {
    @Test
    public void test() {
        Phone phone = new Phone("华为",12);
        phone.listen();
    }
}

abstract class Phone {
    private double size = 1.5;
    public void openPhone(){
        System.out.println("手机开机");
    }
    public abstract void closePhone();
}