第一篇博客

Java基础

Dos命令

常用的Dos命令

#盘符切换
盘名称: (eg: D:)
#查看当前目录下的所有文件
dir
#切换目录
cd change directory(eg: cd ..)(eg: C:\Users\hwj> cd /d E:\Junior )
#清理屏幕
cls
#退出终端
exit
#查看电脑的ip
ipconfig
#打开应用
	calc
	mspaint
	notepad
#ping命令
	ping www.baidu.com
#文件操作
	md 目录名
	rd 目录名
	cd> 文件名
	del 文件名

JDK

卸载jdk

1. 删除jdk的安装目录
2. 删除环境变量里的JAVA_HOME
3. 删除PATH下的关于java的
4. cmd中查看 java -version

安装jdk

1. 官网下载安装（记住安装路径）
2. 配置环境变量 添加JAVA_HOME
3. 配置PATH变量 jdk中的bin目录和jre目录
4. cmd中查看 java -version

Java基础

注释

//单行注释

/*
多行注释
多行注释
*/

/**
* JavaDoc：文档注释  /** */
*/

标识符

关键字


标识符注意点


数据类型

强类型语言

要求变量的使用要严格符合规定，所有变量都遵循先定义后使用

弱类型语言

Java的数据类型分为两大类

基本类型(八大类型)

数值类型

整数类型


int num1 = 10; //最常用
byte num2 = 20;
short num3 = 10;
long num4 = 30L;

浮点类型

float占4个字节

double占8个字节

float num5 = 50.1F
double num6 = 3.1415926535

字符类型

char占2个字节

char name = 'A'
String name_a = "String不是关键字，是类"

boolean类型

占一位字节，其值只要true和false两个

boolean flag = false;

引用类型

类

接口

数组

类型转换

强制类型转换

自动类型转换

int i = 128;
byte b = (byte)i;  //内存溢出

//强制类型转换 (类型)变量名  高--低
//自动转换  低--高

System.out.println(i); //128
System.out.println(b); //-128

注意点

1. 不能对布尔值进行转换
2. 不能把对象类型转换为不相干的类型
3. 在把高容量转换到低容量的时候需要强制转换
4. 转换的时候可能存在内存溢出，或者精度问题！

		//操作比较大的数，要注意溢出问题
        int money = 10_0000_0000;  //Long money = 10_0000_0000L;
        int year = 20;
        long total = (long)money*year;
        System.out.println(total);

字节


数据类型扩展及面试题

//整数扩展       进制     二进制0b     八进制0     十进制     十六进制0x
        int i = 10;
        int i2 = 010;   //八进制
        int i3 = 0x10;  //十六进制

        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);

        //=============================================================================
        //浮点数拓展?  银行业务怎么表示？钱
        // BigDecimal  数学工具类
        //=============================================================================
        //float    有限  离散  舍入误差  大约   接近但不等于
        //double
        //最好完全避免使用浮点数进行比较
        //最好完全避免使用浮点数进行比较
        //最好完全避免使用浮点数进行比较
        float f = 0.1f;     //0.1
        double d = 1.0/10;  //0.1
        System.out.println(f == d);  //false

        float d1 = 231313131313f;
        float d2 = d1 + 1;
        System.out.println(d1 == d2);  //true

        //=============================================================================
        //字符拓展
        //=============================================================================
        char c1 = 'a';
        char c2 = '中';
        System.out.println(c1);
        System.out.println((int) c1);
        System.out.println(c2);
        System.out.println((int) c2);
        //所有字符本质上还是数字
        //编码 Unicode 2字节 0 ~ 65536 Excel 2^16 = 65536  ASII码
        char c3 = '\u0061';   //注意：'\u'不能出现在除转义代码以外的任何注释中
        System.out.println(c3);

        //转义字符 \t 制表符；\n 换行
        System.out.println("Hello\tWorld!");

        System.out.println("======================================================");
        String s1 = new String("hello world");
        String s2 = new String("hello world");
		//因为new关键字会在内存开辟除一片空间，所以开辟了两个空间，对比的是地址的值，所以不相等
        System.out.println(s1 == s2); //false

        String s3 = "hello world";
        String s4 = "hello world";
        System.out.println(s3 == s4); //true

		//布尔值扩展
        boolean flag = true;
        if (flag==true){ } // 新手
        if (flag){ }  // 老手
        //Less is Model 代码要精简易读

变量


变量作用域

类变量

实例变量

局部变量

    //类变量  static
    static double salary = 2500;
    
    //属性：变量
    
    //实例变量：从属于对象; 如果不自行初始化，这个类型的默认值 0 0.0
    //布尔值：默认是false
    //除了基本类型，其余的默认值都是null
    String name;
    int age;


    public static void main(String[] args) {

        //局部变量：必须先声明喝初始化值
        int i = 10;
        System.out.println(i);

        //实例类型
        Demo02 demo02 = new Demo02();
        System.out.println(demo02.name);
        System.out.println(demo02.age);

        //类变量  static
        System.out.println(salary);
        
    }

    //其他方法
    public void add(){

    }

变量命名规则


常量


	//修饰符，不存在先后顺序
    static final double PI = 3.1415926;

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

运算符


自增自减运算符

        // ++  --
        int a = 3;

        int b = a++; //执行完这行代码后，先给b赋值，再自增
        //a++   a = a + 1
        System.out.println(a);  //4
        int c = ++a; //执行这行代码前，先自增，后赋值

        System.out.println(a);  //5
        System.out.println(b);  //3
        System.out.println(c);  //5
        
        //幂运算 2^3 = 8  2*2*2 = 8
        double pow = Math.pow(2, 3);
        System.out.println(pow);

逻辑运算符

        // 与 或 非（取反）
        boolean a = true;
        boolean b = false;

        System.out.println("a && b:"+(a&&b)); // false
        System.out.println("a || b:"+(a||b)); // true
        System.out.println("!(a && b):"+!(a&&b)); //true

        //短路运算
        int c = 5;
        boolean d = (c<4)&&(c++<10);
        System.out.println(d); //false
        System.out.println(c); //5

位运算

        /*
        A = 0011  1100
        B = 0000  1101
        -----------------
        A&B 0000  1100
        A|B 0011  1101
        ~B  1111  0010

        2*8 = 16 2*2*2*2
        效率极高！ 左乘右除
        <<  *2
        >>  /2

        0000 0000    0
        0000 0001    1
        0000 0010    2
        0000 0011    3
        0000 0100    4
        0000 1000    8
        0001 0000    16
         */

        System.out.println(2<<3);  // 16

三元运算符及小结

        int a = 10;
        int b = 20;

        a+=b;
        a-=b;

        //字符串连接符 + ， String
        //字符串在前，转换为String类型
        //字符串在后，还是数值型
        System.out.println(""+a+b); //1020
        System.out.println(a+b+""); //30

		//三元运算符  x ? y : z
		int a = 5;
        int b = 30;
        System.out.println(a>10 ? true : false);

包机制

一般利用公司域名倒置作为包名

JavaDoc生成文档


/**
 * @author hwj
 * @version 1.0
 * @since 1.8
 */
public class Doc {
    
    String name;

    /**
     * 
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception{
        return name;
    }
    
}

通过命令行生成文档

使用IDEA生成javadoc文档

使用IDEA生成JavaDoc文档（IDEA2020.3.2）_idea快捷键将所有javadoc注释转为读模式-CSDN博客

1. 在Toosl中找到如下

2. 选择生成javadoc文档

• 第一步：选择生成JavaDoc文档的范围，我只对一个源文件生成Doc，所以选择文件。
• 第二步：输出目录最好新建一个文件夹，比较有条理和整洁
• 第三步：区域设置，决定文档的语言，简体中文就是zh_CN、繁体(台湾)zh_tw、繁体(香港)zh-hk、英语(香港)en-hk、英语(美国)en-us、英语(英国)en-gb、英语(全球)en-ww
• 第四步：其他命令行参数：如果区域设置为中国，参数一般为-encoding UTF-8 -charset UTF-8
• 第五步：设置完成后点击确定即可生成Doc文档

3. 查看javadoc文档

Java流程控制

用户交互Scanner

next方法：(不会显示空格后面的数据)

        //创建一个扫描对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用next方式接收：");

        //判断用户有没有输入字符串
        if (scanner.hasNext()){
            //使用next方法接收
            String str = scanner.next();
            System.out.println("输出的内容为："+str);
        }

        //凡是IO流的类如果不关闭会一直占用资源，要养成良好的习惯，用完就关
        scanner.close();

nextLine方法：

		//创建一个扫描对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用nextLine方式接收：");
        if (scanner.hasNextLine()){
            String str = scanner.nextLine();
            System.out.println("输出的内容："+str);
        }

        scanner.close();

Scanner的进阶使用

 Scanner scanner = new Scanner(System.in);
        //从键盘接收数据
        int i = 0;
        float f = 0.0f;

        System.out.println("请输入整数：");

        if (scanner.hasNextInt()){
            i = scanner.nextInt();
            System.out.println("整数数据i:"+i);
        }else {
            System.out.println("输入的不是整数数据");
        }

        System.out.println("请输入小数：");

        if (scanner.hasNextFloat()){
            f = scanner.nextFloat();
            System.out.println("小数数据f:"+f);
        }else {
            System.out.println("输入的不是小数数据");
        }

        scanner.close();

我们可以输入多个数字，并求其总和和平均数，每输入一个数字用回车赖确认，通过输入非数字来结束输入并输出执行结果

        Scanner scanner = new Scanner(System.in);

        //和
        double sum = 0;
        int num = 0;

        //通过循环判断是否还有输入，并在里面对每一次进行求和统计
        while (scanner.hasNextDouble()){
            double x = scanner.nextDouble();
            //输入完一次 num要加一
            num++;
            sum += x;
        }
        System.out.println(num+"个数的和为："+sum);
        System.out.println(num+"个数的平均数为："+(sum/num));

        scanner.close();

顺序结构

选择结构

if选择结构（单选择结构，双选择结构，多选择结构）

        Scanner scanner = new Scanner(System.in);
        
        System.out.println("请输入成绩：");
        int score = scanner.nextInt();

        if (score==100){
            System.out.println("满分");
        }else if (score<100 && score>90){
            System.out.println("优秀");
        }else if (score<90 && score>80){
            System.out.println("良好");
        }else if (score<80 && score>60){
            System.out.println("及格");
        }else if (score<60 && score>=0){
            System.out.println("不及格");
        }else {
            System.out.println("输入的成绩不合法");
        }

        scanner.close();

switch选择结构

switch语句不能直接使用比较运算符（如 >、<、>=、<= 等）作为case的条件。switch语句的case部分只能接受常量表达式、字符字面量或枚举常量

        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入等级：");
        String grade = scanner.next();


        switch (grade){
            case "A":
                System.out.println("优秀");
                break;
            case "B":
                System.out.println("良好");
                break;
            case "C":
                System.out.println("及格");
                break;
            case "D":
                System.out.println("不及格");
                break;
            default:
                System.out.println("输入不合法，等级未知");
        }

        scanner.close();

循环结构

While循环

        //计算1+2+3+..+100
        int sum = 0;
        int i = 0;
        while (i<100){
            i++;
            sum += i;
        }
        System.out.println(sum);
    }

DoWhile循环

//计算1+2+3+..+100
        int sum = 0;
        int i = 0;
        do {
            i++;
            sum += i;
        }while (i<100);
        System.out.println(sum);

While和DoWhlie的区别

while先判断后执行，dowhile是先执行后判断

dowhile总是保证循环体会被至少执行一次，这是他们的主要差别！

For循环

练习1：计算0到100之间的奇数和偶数的和

        //计算0到100之间的奇数和偶数的和
        int oddSum = 0;
        int evenSum = 0;

        for (int i = 0;i<=100;i++){
            if (i%2!=0){
                oddSum += i;
            }else {
                evenSum += i;
            }
        }
        System.out.println("奇数的和："+oddSum);
        System.out.println("偶数的和："+evenSum);

练习2：用while或for循环输出1-1000之间能被5整除的数，并且每行输出3个

        //用while或for循环输出1-1000之间能被5整除的数，并且每行输出3个
        int num = 0;
        for (int i = 1;i<=1000;i++){
            if (i%5==0){
                System.out.print(i+"\t");
                num++;
                if (num%3==0){
                    System.out.println();
                }
            }
        }

打印九九乘法表

        //打印九九乘法表
        for (int i = 1; i<=9; i++){
            for (int j = 1;j<=i;j++){
                System.out.print(j+"*"+i+"="+(j*i) + "\t");
            }
            System.out.println();
        }·

增强for循环

        int[] numbers = {10,20,30,40,50};

        for(int x:numbers){
            System.out.println(x);
        }

break & continue

break：break用于强行退出循环，不执行循环中剩余的语句

        int i =0;
        while (i<100){
            i++;
            System.out.println(i);
            if (i==30){
                break;
            }
        }
        
        System.out.println("123");

continue：用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定

        int i =0;
        while (i<100){
            i++;
            if (i%10==0){
                System.out.println();
                continue;
            }
            System.out.print(i);
        }

练习

打印三角形及Debug

        //打印三角形  5行
        for (int i = 1;i<=5;i++){
            for (int j = 5; j >= i ; j--) {
                System.out.print(" ");
            }
            for (int j = 1; j <=i ; j++) {
                System.out.print("*");
            }
            for (int j = 1; j < i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }

Java方法详解

方法的定义和调用


public class Demo {

    public static void main(String[] args) {
        int sum = add(3, 4);
        System.out.println(sum);
    }

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

}

public class Demo {

    public static void main(String[] args) {
        int max = max(10, 20);
        System.out.println(max);
    }

    //比大小
    public static int max(int num1,int num2){
        int result=0;
        if (num1==num2){
            System.out.println("num1==num2");
        }
        if (num1>num2){
            result = num1;
        }else {
            result = num2;
        }
        return result;
    }

}

课后扩展了解

值传递（Java）和引用传递

方法的重载


public class Demo {

    public static void main(String[] args) {
        int max = max(10, 20);
        System.out.println(max);

        double max1 = max(10.0, 23.33);
        System.out.println(max1);
    }

    //比大小
    public static int max(int num1,int num2){
        int result=0;
        if (num1==num2){
            System.out.println("num1==num2");
            return 0;//终止方法
        }
        if (num1>num2){
            result = num1;
        }else {
            result = num2;
        }
        return result;
    }

    public static double max(double num1,double num2){
        double result=0.0;
        if (num1==num2){
            System.out.println("num1==num2");
            return 0;//终止方法
        }
        if (num1>num2){
            result = num1;
        }else {
            result = num2;
        }
        return result;
    }

}

可变参数

public class Demo03 {
    public static void main(String[] args) {
        //调用可变参数的方法
        printMax(34,3,3,2,56.5);
        printMax(new double[]{1,2,3});
    }

    public static void printMax(double... numbers){
        if (numbers.length==0){
            System.out.println("没有参数传入");
            return;
        }

        double result = numbers[0];

        for (int i = 1; i < numbers.length ; i++) {
            if (numbers[i]>result){
                result = numbers[i];
            }
        }

        System.out.println("最大值是："+result);

    }
}

递归


// 2! 2*1
public static void main(String[] args) {
    int f = f(4);
    System.out.println(f);
}

//2   2 * f(1)
public static int f(int n){
    if (n==1 || n==0){
        return 1;
    }else {
        return n*f(n-1);
    }
}

练习

写一个计算器，要求实现加减乘除，并且能够循环接收新的数据
思路推荐：
写4个方法：加减乘除
利用循环+switch进行用户交互
传递需要操作的两个数
输出结果

Java数组

数组的声明和创建


		//定义，声明数组
        int[] numbers;
        //创建一个数组
        numbers = new int[3];

        numbers[0]=1;
        numbers[1]=2;
        numbers[2]=3;

        for (int i = 0; i < numbers.length; i++) {
            System.out.println(numbers[i]);
        }

三种初始化及内存分析


       //静态初始化
        int[] a = {1,2,3,4,5};
        
        //动态初始化
        int[] b = new int[10];
        b[0]=10;
        

下表越界及小结

ArrayIndexOutOfBoundsException


数组的使用

public class ArrayDemo03 {
    public static void main(String[] args) {
        int[] arrays = {2,3,4,1,5};

        printArray(arrays);
        System.out.println();
        int[] reserve = reserve(arrays);
        printArray(reserve);

    }

    //打印数组元素
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+"\t");
        }
    }

    //反转数组
    public static int[] reserve(int[] arrays){
        int[] result = new int[arrays.length];
        //反转的操作
        for (int i = 0, j=result.length-1;i < arrays.length; i++,j--) {
            result[j] = arrays[i];
        }
        return result;
    }

}

二维数组

        int[][] arrays = {{1,2},{1,3},{1,4}};
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j < arrays[i].length; j++) {
                System.out.println(arrays[i][j]);
            }
        }

Arrays类讲解

public class ArrayDemo06 {

    public static void main(String[] args) {

        int[] a = {1,2,4,999,524,1111111,7815623};

        System.out.println(a);
        //打印数组元素Arrays.toString(a)
        System.out.println(Arrays.toString(a));

        //数组进行排序：升序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));

        //数组填充
        Arrays.fill(a,0);
        printArray(a);

    }

    public static void printArray(int[] a){
        for (int i = 0; i < a.length; i++) {
            if (i==0){
                System.out.print("[");
            }
            if (i==a.length-1){
                System.out.print(a[i]+"]");
            }else {
                System.out.print(a[i]+", ");
            }
        }
    }

}

冒泡排序


import java.util.Arrays;

public class Demo01 {

    public static void main(String[] args) {
        int[] a = {3,5,44,75,1256,15,1};
        int[] bubbleSort = bubbleSort(a);
        System.out.println(Arrays.toString(bubbleSort));
    }

    /*
    冒泡排序
        1、比较数组，两个相邻的元素，如果第一个数比第二个书打，就交换位置
        2、每一次比较，都会产生出一个最大，或者最小的数字
        3、下一轮则可以少一次排序
        4、依次循环，直至结束
     */
    public static int[] bubbleSort(int[] arrays){
        int temp = 0;
        //外层循环，判断我们要走多少次
        for (int i = 0; i < arrays.length - 1; i++) {

            //通过flag标识位减少没有意义的比较
            boolean flag = false;

            //内层循环，比较判断两个数
            for (int j = 0; j < arrays.length-1-i; j++) {
                if (arrays[j+1]>arrays[j]){
                    temp = arrays[j];
                    arrays[j] = arrays[j+1];
                    arrays[j+1] = temp;
                    flag = true;
                }
            }
            if (flag==false){
                break;
            }
        }
        return arrays;
    }
}

稀疏数组


public class SparseArray {

    public static void main(String[] args) {
        /*
        1、创建一个二维数组  11*11
        2、0：没有棋子，   1：黑棋，   2：白棋
         */
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        //输出原始的数组
        System.out.println("输出原始的数组");

        //第一个for是打印一维数组，第二个for是打印二维数组
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

        //转换为系数数组保存
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1.length; j++) {
                if (array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数："+sum);

        //2、创建一个稀疏数组的数组
        int[][] array2 = new int[sum+1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

        //遍历二维数组，将非零的值，存放到稀疏数组中
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j]!=0){
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }

        //输出稀疏数组
        System.out.println("稀疏数组");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+"\t"
                        +array2[i][1]+"\t"
                        +array2[i][2]+"\t");
        }

        System.out.println("===================================");
        System.out.println("还原");
        //1、读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //2、给其中的元素还原它的值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        //3、打印
        //输出原始的数组
        System.out.println("输出还原的数组");

        //第一个for是打印一维数组，第二个for是打印二维数组
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

    }

}

面向对象(OOP)



回顾方法的定义

方法的定义

1. 修饰符
2. 返回类型

//Demo01:类
public class Demo01 {

    //main:方法
    public static void main(String[] args) {
        
    }
    
    /*
    修饰符 返回值类型 方法名(...){
        方法体
        return 返回值;
        }
     */
    public String sayHello(){
        return "Hello World!";
    }
    
    public int max(int a,int b){
        return a>b ? a : b;
    }
    
}

3. break和return的区别

​ break:跳出switch，结束循环

​ return:结束方法，返回结果

4. 方法名：注意规范就行，见名知意

5. 参数列表：（参数类型，参数名）

6. 异常抛出

回顾方法的调用

方法的调用

1. 静态方法

2. 非静态方法

3. 形参和实参:Java是值传递

4. 值传递和引用传递

   public class Demo03 {
       public static void main(String[] args) {
           Person person = new Person();
           System.out.println(person.name);//null
           change(person);
           System.out.println(person.name);//AA
   
       }
   
       public static void change(Person person){
           //person是一个对象，指向的 ---》Person person = new Person(); 这是一个具体的人，可以改变属性
           person.name = "AA";
       }
   }
   
   class Person{
       String name;
   }
   

5. this关键字

类与对象的创建


类：属性和方法（抽象的）

对象：类实例化

构造器详解

构造器：

1. 和类名相同
2. 没有返回值

作用：

1. new 本质在调用构造方法
2. 初始化对象的值

注意点：

1. 定义有参构造之后，如果想使用无参构造，需要显示的定义一个无参构造


创建对象内存分析


简单小结类与对象

1. 类与对象：类是一个模板：抽象，对象是一个具体的实例
2. 方法：定义、调用
3. 对应的引用：

​ 引用类型：基本类型（8）

​ 对象是通过引用来操作的 栈---->堆

4. 属性：字段Field 成员变量

​ 默认初始化：

​ 数值 0/0.0

​ char: u0000

​ 引用：null

5. 对象的创建与使用

​ 必须使用new关键字创造对象，构造器 Person aa = new Person();

​ 对象的属性 aa.name

​ 对象的方法 aa.sleep()

6. 类

​ 静态的属性

​ 动态的方法

三大特性

封装、继承、多态

封装详解

private

主要是对属性，private私有的


什么是继承

定义

extends，在Java种，所有的类，都默认直接或者间接继承Object类


Person类：

public class Person {

    //public
    //protected
    //default
    //private
    private int money = 10_0000_0000;

    public void say(){
        System.out.println("说一句话");
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

Student类

public class Student extends Person {

}

Teacher类

public class Teacher extends Person {
}

Application类

public class Application {
    public static void main(String[] args) {

        Student student = new Student();
        System.out.println(student.getMoney());
        student.say();

    }
}

Super详解

super注意点：

1. super调用父类的构造方法，必须在构造方法的第一个
1. super必须只能出现在子类的方法或者构造方法中
1. super 和 this 不能同时调用构造方法

VS this:

​ 代表的对象不同：

​ this : 本身调用者这个对象

​ super： 代表父类对象的应用

方法重写

重写：需要有继承关系，子类重写父类的方法！

1. **方法名必须相同**
1. **参数列表必须相同**
1. **修饰符：可以扩大，不能缩小  public>protected>default>private**
1. **抛出的异常： 范围：可以缩小，但不能扩大  ClassNotFoundException （小）--》  Exception（大）** 

重写：子类和父类的方法名必须一致，但方法体不同！

为什么要重写？

1. 父类的功能：子类不一定需要，或者不一定满足！

@Override

什么是多态

定义


小结

多态注意事项：

1. 多态是方法的多态，属性没有多态
2. 父类和子类，有联系，类型转换异常！ ClassCastException
3. 存在条件，继承关系，方法需要重写，父类引用指向子类对象 Father f = new Son();
4. 有些方法无法重写
   1. static方法：属于类 它不属于实例
   2. final：常量，在常量池中
   3. private方法：私有的，无法重写

instanceof和类型转换

小结

1. 父类引用指向子类的对象
2. 把子类转换为父类，向上转型
3. 把父类转换为子类，向下转型：强制转换
4. 方便方法调用，减少重复的代码！简洁

static关键字详解

静态属性：

静态方法：

静态代码块

抽象类

abstract

1. 抽象类的所有方法，继承了它的子类，都要实现它的方法，除非继承它的子类也是abstract
2. 不能new这个抽象类，只能靠子类去实现它：约束！
3. 抽象方法必须在抽象类中
4. 抽象的抽象：约束

思考题：

1. 抽象类不能new，那么它存在构造器吗？

​ 存在，用于子类super调用

2. 抽象类存在的意义

​ 抽象类就是来实现封装，多态的增强代码的可扩展性

接口的定义与实现

作用：

1. 约束
2. 定义一些方法，让不同的人实现
3. public abstract
4. public static final
5. 接口不能被实例化，接口中没有构造方法
6. implements可以实现多个接口
7. 必须要重写接口中的方法


N种内部类


Error和Exception





捕获和抛出异常

try...catch

throw

throws

public class Demo01 {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;
        
        //假设要捕获多个异常，需要从小到大捕获
        
        try { //监控区域
            System.out.println(a/b);
        }catch (Error e){  //捕获异常 catch(想要捕获的异常类型),
            System.out.println("程序出现异常，变量b不能为0");
        }catch (Exception e){
            e.printStackTrace(); //打印错误的栈信息
        }catch (Throwable t){
            System.out.println("Throwable");
        }
        finally {
            System.out.println("finally");
        }
    }
    //finally，可以不要finally，假设IO，资源，关闭
}

快捷键：Crlt+Alt+t

public class Demo01 {
    public static void main(String[] args) {
        try {
            new Demo01().test(1,0);
        } catch (ArithmeticException e) {
            e.printStackTrace();
        }
    }
    public void test(int a,int b) throws ArithmeticException{
        if (b==0){
            throw new ArithmeticException(); // 主动抛出异常,一般在方法中使用
        }
        System.out.println(a/b);
    }
}

自定义异常及经验小结


自定义异常类：

public class MyException extends Exception {

    //传递数字，如果数字大于10
    private int detail;

    public MyException(int a){
        this.detail = a;
    }

    //toString:异常的打印信息
    @Override
    public String toString() {
        return "MyException{" + detail + '}';
    }
}

测试：

public class Test {

    //可能会存在的异常方法
    static void test(int a) throws MyException{

        System.out.println("传递的参数为："+a);

        if (a>10){
            throw new MyException(a); // 抛出
        }
        System.out.println("OK");

    }

    public static void main(String[] args) {
        try {
            test(11);
        } catch (MyException e) {
            System.out.println("MyException=>"+e);
        }
    }

}

实际应用中的经验总结

1. 处理运行异常时，采用逻辑去合理规避同时辅助 try-catch 处理
2. 在多重 catch 块后面，可以加一个catch（Exception）来处理可能会被遗漏掉的异常
3. 对于不确定的代码，也可以加上try-catch，处理潜在的异常
4. 尽量去处理异常，切忌知识简单地调用printStackTrace()去打印输出
5. 具体如何处理异常，要根据不同地业务需求和异常类型去决定
6. 尽量添加finally语句块去释放占用地资源

JavaSE总结