JavaSe复习

🔎初识Java

---

🌻Java的由来

Java创始人
詹姆斯·高斯林(James Gosling)

Java 语言源于 1991 年 4 月，Sun 公司 James Gosling博士 领导的绿色计划(Green Project) 开始启动，此计划最初的目标是开发一种能够在各种消费性电子产品(如机顶盒、冰箱、收音机等)上运行的程序架构。

Java口号：Write once, Run anywhere（一次编译，到处运行）

---

🌻Java的编译，运行

---

🌻main方法的介绍

🌼一个简单的Java程序

public static void main(String[] args) {
        System.out.println("Hello World!");
    }

注意：在一个源文件中只能有一个public修饰的类，且名字与文件名相同

---

🌼JDK,JRE,JVM之间的关系

JDK(Java Development Kit):Java开发工具包，提供给Java程序员使用，包含了JRE，同时还包含了编译器javac与自带的调试工具Jconsole、jstack等。
JRE(Java Runtime Environment):Java运行时环境，包含了JVM，Java基础类库。是使用Java语言编写程序时所需的运行环境。
JVM：Java虚拟机

---

🌻注释

单行注释：// 注释内容
多行注释：/* 注释内容 /
文档注释： /* 文档注释 */

---

🌻标识符

标识符中可以包含：字母、数字以及下划线和 $ 符号等
标识符不能以数字开头，也不能是关键字，且严格区分大小写

小建议：
类名尽可能使用大驼峰（每个单词的首字母大写）
方法名，变量名尽可能使用小驼峰（首字母小写，后面每个单词的首字母大写）

---

🔎数据类型与变量

注意：只有byte,char的包装类不是首字母大写，其余基本数据类型的包装类均为首字母大写

🌻取值范围

---

🔎运算符

🌻算术运算符

---

🌻关系运算符

---

🌻逻辑运算符

---

🌻位运算符

---

🌻移位运算符

---

🌻条件运算符

---

🔎逻辑控制

🌻顺序结构

按照代码书写的顺序一行一行执行

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

---

🌻分支结构

---

🌻循环结构

---

🔎方法

Java中的方法，类似于C语言中的函数
方法的意义：可以直接调用，而不用重复“造轮子”

🌻重载

重载不一定要写在同一个类中。子类可以重载父类方法（继承）

---

🌻重写

---

🌻重载与重写的区别

---

🌻递归

---

🔎数组

数组是相同类型元素的一个集合，在内存中是一段连续的空间

🌻初始化

🌼静态初始化

public static void main(String[] args) {
        int[] arr1 = {1,2,3};
        int[] arr2 = new int[]{1,2,3};
    }

静态初始化可以简写，省去后面的new int[ ]

---

🌼动态初始化

public static void main(String[] args) {
        int[] array = new int[3];
    }

---

🌼未初始化默认值

---

🌻遍历数组

---

🌻数组作为参数和返回值

🌼数组作为参数

public static void func(int[] arr) {
        
    }
    public static void main(String[] args) {
        int[] array = new int[3];
        func(array);
    }

---

🌼数组作为返回值

public static int[] func(int[] arr) {
        return arr;
    }
    public static void main(String[] args) {
        int[] array = new int[3];
        func(array);
    }

---

🔎类和对象

类与对象的关系：类实例化后产生对象
class Cat = new Cat();

🌻类

🌼成员变量

定义在方法外部，类的内部

❀普通成员变量

由对象调用，内存在对象中

---

❀静态成员变量

有static关键字，由类名调用，内存在方法区

---

🌼成员方法

❀普通成员方法

---

❀静态成员方法

有static关键字，通过类名调用

注意事项：
在静态方法内部不能直接调用非静态的成员方法
非静态的数据成员都需要对象来引用，静态方法里面不能使用this
非静态成员方法内部可以使用静态成员方法

---

🌻对象

一个类可以实例化多个对象

---

🌻this关键字

代表当前对象的引用

🌼用法

---

🌻构造方法

作用：初始化成员变量
可以重载
编译器会默认提供一个不带参数的构造方法
当我们自己提供构造方法后，编译器就不再提供默认的构造方法
无返回值
实例化对象时调用

---

🌻封装

将内部实现细节隐藏起来,避免类外直接获取想要隐藏的属性，使用关键字private修饰

🌼get and set

利用get and set方法对封装的数据进行访问

---

🌼导包

利用import在当前类导入其他包的类

---

🌻代码块

🌻内部类

🌼非静态内部类

即未被static修饰的成员内部类

class OuterClass {
    public int data1 = 1;
    private int data2 = 2;
    public static int data3 = 3;
    //非静态内部类
    class InnerClass {
        public int data1 = 11111;
        public int data4 = 4;
        private int data5 = 5;
        public static final int data6 = 6;

        public void func() {
            System.out.println("InnerClass:func()");
        }
    }
}

---

🌼静态内部类

被static修饰的内部成员类

class OuterClass {
    public int data1 = 1;
    private int data2 = 2;
    public static int data3 = 3;

    static class InnerClass {
        public int data4 = 4;
        private int data5 = 5;
        public static int data6 = 6;

        public void func() {
            System.out.println("InnerClass:func()");
        }
    }
}

---

🌼匿名内部类

---

🔎继承和多态

🌻继承

作用：对共性的抽取，实现代码的复用

🌼一个简单的继承

class A {
    public String color;
    public int age;
    
    public static int size;//静态
}

class B extends A {
    public String type;
    
}

子类继承了父类的所有非静态成员（变量/方法）

---

🌼super关键字

代表父类对象的引用

❀用法

🌼super与this的区别

super()和this()都只能在构造方法的第一行使用，所以只能选择其中一个
super只能出现在子类方法或构造方法中
this没有父类也可以使用，super只能在含有父类情况下使用

---

🌼执行顺序

在继承关系上存在静态代码块，非静态代码块和构造方法

---

🌼访问修饰限定符

private default（默认） protected public
访问权限：public>protected>default>private

---

🌼final关键字

❀修饰变量（表示该变量不能修改）

final int a = 0;
        //a = 1;//修饰变量，表示为常量（不能修改）

---

❀修饰类（表示该类不能被继承）

final class A {
    
}

/*class B extends A {
    
}*/

---

❀修饰方法（表示该方法不能被重写）

class C {
    public final void func() {
        
    }
}

class D extends C {
    /*@Override
    public void func() {//该方法不能被重写，因为父类的方法被final修饰
        System.out.println("hello");
    }*/
}

---

🌻多态

🌼向上转型

只能访问父类自己的成员（属性/方法），不能访问子类的成员（属性/方法）

class C {

}

class D extends C {

}

public class Test {
    public static C method() {
        return new D();//向上转型
    }

    public static void main3(String[] args) {
        method();
    }

    public static void func(C c) {//向上转型

    }

    public static void main2(String[] args) {
        D d = new D();
        func(d);//向上转型
    }

    public static void main1(String[] args) {
        C c = new D();//向上转型
    }
}

---

🌼向下转型

class C {

}

class D extends C {

}

class E extends C {

}

public class Test {
    public static void main(String[] args) {
        C c = new D();
        //E e = (E)c;//向下转型--不建议使用
        if(c instanceof E) {
            E e = (E)c;//一定要使用建议搭配instance of 关键字
        }
    }
}    

---

🔎抽象类和接口

🌻抽象类

特性
不能被实例化，被用于继承
包含抽象方法和非抽象方法
当一个非抽象类继承这个抽象类时，必须重写这个抽象类的抽象方法
抽象方法不能被private，final，static修饰

---

🌻接口

特性
成员变量默认是public static final修饰
成员方法默认是public abstract修饰

---

🔎String类

🌻字符串的不可变性

String是一种不可变对象

final表示String不可被继承，但仍可以修改字符串里的内容
那为什么String是一种不可变对象呢？
因为里面的字符是被private修饰的，是封装的（不能被访问）

---

🌻StringBuilder和StringBuffer

因为String的不可变性，为了方便字符串进行修改，可以使用StringBuilder和StringBuffer

StringBuilder和StringBuffer修改字符串内容时均不会创创建一个新的对象

String和StringBuilder类转换
String变为StringBuilder: 利用StringBuilder的构造方法或append()方法
StringBuilder变为String: 调用toString()方法

---

🔎异常

🌻异常的简单分类

🌼编译时异常/受查异常（IOException）

---

🌼运行时异常/非受查异常（RuntimeException）

public static void main(String[] args) {
        char[] arr = null;
        System.out.println(arr);
        System.out.println("运行时异常--空指针异常");
    }

---

🌻throw和throws的区别

throw代表抛出异常
throws代表声明异常，可用于编译（受查）异常，使其编译正常

---

🌻自定义异常

1.自定义异常类，然后继承自Exception 或者 RunTimeException
2.实现一个带有String类型参数的构造方法，参数含义：出现异常的原因

class WrokException extends RuntimeException{
    public WrokException(String s) {
        super(s);
    }
}

---

🔎总结