#day1 Markdown学习

标题：

#+“ ”+标题名字

二级标题：

##+“ ”+标题名字

三级标题：

###+“ ”+标题名字

井号+空格+标题名字+回车

字体

hello，world

hello，world

hello，world

~~hello，world~~

引用

java

一个“>”符号

分割线

三个杠：“—”

三个星：“***”

图片

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dyjMi1E9-1663406130691)(https://profile.csdnimg.cn/8/3/8/1_yzero11111)]

超链接

点击跳转到b站网课

列表

（减号+“ ”空格）

表格

名字	性别	生日
张三	男	1997.1.1

查看源代码模式

代码

public

“```”+代码名称

‘hello’

day2

p19，java程序运行机制

编译型：直译
解释型：网页、服务器脚本（对速度要求不高）

java：先编译再解释

p20p21，ide：集成开发环境

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Fp3m1DEp-1663406170630)(C:\Users\yzero\Desktop\QQ图片20220909170022.png)]

p21注释

单行注释
多行注释
文档注释

p22标识符和关键字

java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。

标识符是大小写敏感的

p23数据类型讲解

强类型语言：要求变量的使用严格规定，所有的变量都必须先定义后才能使用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Lg8NZSdW-1663406170631)(C:\Users\yzero\Desktop\微信图片_20220909174017.png)]

引用数据类型：1.类2.接口3.数组

p24

p25类型转换

p26变量

day 3

p26变量

变量作用域

类变量
```
//static从属于类
```
实例变量
局部变量

常量

可理解为一个特殊的变量，关键字：

xxxxxxxxxx public class TestDemo { public static void main(String[] args) { //打印三角形 5行 for (int i = 1; i <= 5; i++) {//5.for 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

final为一个修饰符，不存在先后顺序

驼峰原则：除了第一个单词以外后面单词首字母大写

public class demo09 {
    //final为一个修饰符，不存在先后顺序
    static final double PI=3.14;

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

p27运算符

算术运算符：+、-、*、/

赋值运算符：

关系运算符：

逻辑运算符：与或非：&&、||、！

位运算符：

条件运算符：

ctrl+d  复制当前行到下一行

p28自增自减运算符

一元运算符：

++：自增

–：自减

p29逻辑运算符

package operator;

public class Demo05 {
    public static void main(String[] args) {
        //与或非
        boolean a=true;
        boolean b=false;
        System.out.println("a && b:"+(a&&b));
        System.out.println("a || b:"+(a||b));
        System.out.println("!(a && b):"+!(a&&b));
        //短路运算
        int c=5;
        boolean d=(c<4)&&(c++<10);//假设前面为错，后面的运算式根本不会执行
        System.out.println(d);
        System.out.println(c);
    }
}

位运算

//位运算：单个位的运算
        /*
        * A=0011 1100
        * B=0000 1101
        * A&B =0000 1100
        * A|B =0011 1101
        * A^B =0011 0001
        * ~B  =1111 0010
        *
        * <<   >>左移和右移
        2*8=16=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
        << 左移就是*2
        >> 右移就是/2
        */

<< 左移就是*2
.>>右移就是/2

三元运算符及小结

public class Demo07 {
    public static void main(String[] args) {
        int a=10;
        int b=20;
        a+=b;
        System.out.println(a);
        //字符串连接符
        //+ ， String
        System.out.println(a+b);
        System.out.println(""+a+b);
        System.out.println(a+b+"");
    }

区分以下两行：

System.out.println(“”+a+b);
System.out.println(a+b+“”);

三元运算符
```
x  ?   y   :   z
```

优先级：（）最高！！！

p30包机制

**包的本质就是文件夹 **

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

import com.base.*;

*为通配符，可以导入某个包里所有的类

p31JavaDoc生成文档

p32Java流程控制：用户scanner交互

可以通过scanner类来获取用户的输入

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7e6Vhoy6-1663406190476)(C:\Users\yzero\Desktop\QQ图片20220910182335.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0SYFG76I-1663406190477)(C:\Users\yzero\Desktop\QQ图片20220910183508.png)]

next():以空格为结束符

nextLine()：以回车为结束符

next：获取字符
has：判断是否还有输入

p35顺序结构

p36选择结构

p37switch多选择结构

看源码

p38while循环

p39dowhile循环

至少会执行一次

p40for循环

for是最有效的循环结构

可以是空语句！！

public class ForDemo03 {
    public static void main(String[] args) {
        //用while或for循环输出1-1000之间能被5整除的数，并且每行输出3个
        for (int i = 0; i < 100; i++) {
            if(i%5==0){
                System.out.print(i+"\t");
            }
            if(i%(5*3)==0){
                System.out.println();
            }
            //println输出完会换行
            //print输出完不会换行
        }

p41九九乘法表

day4

p42增强for循环

public class ForDemo05 {
    //遍历数组中的元素
    public static void main(String[] args) {
        //增强for循环
        int[] numbers={10,20,30,40,50};
        for(int x:numbers){
            System.out.println(x);
        }
    }
}

break continue

break用于强制退出循环（用于强制退出循环不在执行剩余的循环语句）
continue用于终止某次循环(碰到continue就从循环第一句开始执行，仅仅只是跳过当前循环）

goto（理解以下就好）

java没有goto但可以加标签实现goto

以下outer为标签：

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

        //打印101-150之间所有质数
        //质数：只能被1和她本身整除的数
        int count = 0;
        outer:
        for (int i = 101; i < 150; i++) {
            for (int j = 2; j < i / 2; j++) {
                if (i % j == 0) {
                    continue outer;
                }
            }
            System.out.println(i + "");
        }
    }
}

p44打印三角形及Debug

public class TestDemo {
    public static void main(String[] args) {
        //打印三角形 5行
        for (int i = 1; i <= 5; i++) {//5.for
            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();
        }
    }
}

day5

p45java方法详解

什么是方法

System.out.println();

System:类

out：对象

println：方法

一个方法只完成一个功能（原子性）

方法的定义及调用

p46方法的定义

java是值传递

p47方法的重载

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fwBHi2Vi-1663406261057)(D:\大三上\java自学图片笔记\111.png)]

方法重载规则：

方法名称必须相同
参数列表必须不同

例：

public static int add(int a,int b){//形式参数
    return a+b;
    }
public static int add(int a,int b,int c){//形式参数
    return a+b+c;
}

//比大小
public static int max(int a,int b){
    if(a==b){
        return 0;
    }
    if(a<b){
        return b;
    }
    return a;
}
public static double max(double a,double b){
    if(a==b){
        return 0;
    }
    if(a<b){
        return b;
    }
    return a;
}

p48命令行传递参数

p49可变参数

//可变参数
//不定项参数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ao6m7pYX-1663406261060)(D:\大三上\java自学图片笔记\QQ图片20220913100518.png)]

只能放在最后面

p50递归

递归：自己调用自己

public class Demo05 {
    public static void main(String[] args) {
        Demo05 test=new Demo05();
        test.test();
    }
    //StackOverflowError栈溢出异常
    public void test(){
        test();
    }
}

递归头：

递归尾：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Zps0ypaO-1663406261062)(D:\大三上\java自学图片笔记\QQ图片20220913105404.png)]

p51java数组

数组的使用

多维数组

Arrays类

稀疏数组

什么是数组

数组是相同类型数据的有序集合
数组表示的是相同类型的若干数据，按照一定的先后次序排列组合而成。
其中，每一给数据称作一个数组元素，每个数据可以通过下标来访问

p52数组声明创建

首先必须声明数组变量

数组的定义：

int[] nums;//1.定义（首选）
int nums2[];//定义  c、c++语言风格

int[] nums;//1.定义（首选）仅仅是声明
//在java语言中使用new关键字
nums=new int[10];//分配空间
//这里面可以存放十个int类型数字

数组的初始化

//数组初始化
//1.静态初始化
int[] a={1,2,3};
Man[] mans={new Man(1,1),new Man(2,2)};
//2.动态初始化
int[] a1=new int[2];
a1[0]=1;
a1[1]=2;

3.数组的默认初始化：

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

获取数组长度：数组名.length

p53三种初始化及内存分析

java内存：
1.堆:存放new的对象和数组
2.栈
3.方法区

1.声明数组：int[] array=null;

2.创建数组：array=new int[10]；

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FJX1No93-1663406261062)(D:\大三上\java自学图片笔记\123123123.png)]

p54数组基本特点

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZXX0UHSF-1663406261063)(D:\大三上\java自学图片笔记\数组基本类型.png)]

数组下标从0开始！！！

1.数组也是对象。数组元素相当于数组的成员变量

2.数组长度确定，不可变。

p55数组的使用（重点）

for-each遍历数组

public static void main(String[] args) {
    int[] arrays={1,2,3,4,5};
    //for-each循环
    //数组名.for+enter键
    for (int array : arrays) {
        System.out.println(array);
    }
}

数组的反转

//反转数组
public static int[] reverses(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;
}

p56多维数组

p57arrays类讲解

day6

p57arrays类讲解

arrays类

int[] a={123,3452,8,3,7,3,1};
System.out.println(a);

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

//排序
    Arrays.sort(a);//自动对数组进行排序
    System.out.println(Arrays.toString(a));

//填充数组
Arrays.fill(a,0);
System.out.println(Arrays.toString(a));

结果：

[1, 3, 3, 7, 8, 123, 3452]
[0, 0, 0, 0, 0, 0, 0]

day7

p58

冒泡排序

//冒泡排序
public static int[] sort(int[] array) {
    int t;
    for (int i = 0; i < array.length; i++) {
        for (int j = 0; j < array.length; j++) {
            if (array[i] < array[j]) {
                t = array[i];
                array[i] = array[j];
                array[j] = t;
            }
        }
    }
    return array;
}

p59稀疏数组

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rYhfeM6x-1663406287187)(D:\大三上\java自学图片笔记\稀疏数组.png)]

public static void main(String[] args) {
    //1.创建一个二维数组  11*11    0:没有棋子    1：黑棋    2：白棋
    int[][] array1= new int[11][11];
    array1[1][2]=1;
    array1[2][3]=1;
    //输出原始数组
    System.out.println("输出原始数组");
    //foreach循环（遍历二维数组）
    for (int[] ints : array1) {
        for (int anInt : ints) {
            System.out.print(anInt+"\t");
        }
        System.out.println();
    }
    System.out.println("==========================================");
    //转换为稀疏数组来保存
    //1.获取有效值个数
    int sum=0;
    for (int i = 0; i < 11; i++) {
        for (int j = 0; j < 11; j++) {
            if(array1[i][j]!=0){
                sum++;
            }
        }
    }
    System.out.println("有效值个数："+sum);

    //2.创建一个稀疏数组的数组
    int[][] array2=new int[sum+1][3];
    /*行=有效值个数+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");
    }

    //还原稀疏数组
    //1.读取稀疏数组的值
    int[][] array3=new int[array2[0][0]][array2[0][1]];
    //2.给其中的元素还原值
    for (int i = 1; i < array2.length; i++) {//第0行是头部信息
        array3[array2[i][0]][array2[i][1]]=array2[i][2];
    }
    //3.打印数组
    System.out.println("还原后的数组：");
    for (int[] ints : array3) {
        for (int anInt : ints) {
            System.out.print(anInt+"\t");
        }
        System.out.println();
    }
}

面向对象编程

p60面向对象编程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BLF6yAlI-1663406287189)(D:\大三上\java自学图片笔记\面向对象.png)]

属性+方法=类

面向对象编程的本质：以类的方式组织代码，以对象的组织（封装）数据

抽象
三大特性：封装、继承、多态

先有类后有对象，类是对象的模板。

p61回顾方法定义

/*
修饰符  返回值类型  方法名（...）{
    //方法体
    return 返回值；
    }
 */

break和return的区别：
return：方法结束
break：退出循环
方法名：驼峰命名、简明知意
参数列表：（参数类型，参数名）…
异常抛出：

//demo01类
public class Demo01 {
    //main 方法
    public static void main(String[] args) {

    }

    /*
    修饰符  返回值类型  方法名（...）{
        //方法体
        return 返回值；
        }
     */
    public String sayHello(){
        return "helli World";
    }

    public void print(){
        return;
    }

    public int max(int a,int b){
        return a>b?a:b;
    }
    
    //抛出异常
    //异常：数组下标越界异常：
    public void readFlie(String file)throws IOException{
        
    }
}

p62方法的调用

public class Demo02 {

    //静态方法  static


    //非静态方法

    public static void main(String[] args) {
        //要先实例化类
        //对象类型  对象名=对象值
        Student student=new Student();
        student.say();
    }
    //static是和类一起加载的
    public static void a(){
        b();
    }
    //没有static的类是在类实例化之后才调用的
    public void b(){

    }
}

p63类与对像的关系

//学生类
public class Student {

    //属性：字段
    String name;
    int age;

    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }
}

//一个项目应该只存在一个类方法
public class Application {
    public static void main(String[] args) {

        //类是抽象的，要实例化
        //类实例化后会返回一个自己的对象
        //student对象就是Student类的一个实例！
        Student xiaoming = new Student();
        Student xiaohong = new Student();

        xiaoming.name="小明";
        xiaoming.age=3;
        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);
    }
}

p64构造器详解

一旦定义了有参构造，无参就必须显示定义

//实例化初始值
//1.使用new关键字，本质是在调用构造器
//2.用来初始化值
public Person(){
    //构造器作用：实例化一些初始值
    this.name="罗渽民";
}

//有参构造:一旦定义了有参构造，无参就必须显示定义
public Person(String name){
    //构造器作用：实例化一些初始值
    this.name=name;
}

all+insert  生成构造器快捷键

构造器：
    1.和类名相同
    2.没有返回值
作业：
    1.new本质在调用构造方法
    2.初始化对象的值
注意点：
    1.定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造
Alt+Insert

p65创建对象内存分析

p66

类与对象：类是一个模板：抽象。对象是一个实例

1.方法：定义、调用

2.对应的应用：应用类型：基本类型

3.对象是通过引用来操作的

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

默认初始化：

数字：0 0.0

char：u0000

boolean：false

引用：null

修饰符属性类型属性名=属性值

5.对象的属性和使用

必须使用new关键字创造对象，构造器 Person wys=new Person();
对象的属性 wys.name
对象的放啊 wys.sleep

6.类：

静态的属性

动态的方法

封装、继承、多态

p67封装详解

高内聚，低耦合

高内聚：类的内部数据操作细节自己完成，不许外部干涉

低耦合：仅暴露少量的方法给外部使用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jDY3F7Fz-1663406287189)(D:\大三上\java自学图片笔记\封装.png)]

p68继承

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yB5ArpVd-1663406287190)(D:\大三上\java自学图片笔记\继承.png)]

ctrl+h   继承树

在java中所有的类，都默认继承object类

p69super

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

对比this：
    代表的对象不同：
        this：本身调用这个对象
        super：代表父类对象的应用
    前提：
        this：没有继承也可以使用
        super：只能在继承条件下才可以使用
    构造方法:
        this():调用本类的构造
        super():调用父类的构造

p70方法重写

public static void main(String[] args) {
    A a=new A();
    a.test();

    //父类的引用指向了子类
    B b=new A();
    b.test();
    /*
    即b是A new出来的对象，因此调用了A的方法
    因为静态方法是类的方法，而非静态是对象的方法
    有static时，b调用了B类的方法，因为b是用b类定义的
    没有static时，b调用的是对象的方法，而b是用A类new的*/
}

重写（只针对于方法）：需要有继承关系，子类重写父类的方法
    1.方法名必须相同
    2.参数列表也必须相同
    3.修饰符：范围可以扩大：public>protected>default>private
    4.抛出的异常：范围可以被缩小，但不能扩大：ClassNotFound
    子类方法和父类必须一致，方法体不同
为什么需要重写？
    1.父类的功能子类不一定需要，或者不一定满足
    alt+insert:->override

day8

p71多态

public static void main(String[] args) {
    //一个对象的实际类型是确定的
    //new Student();

    //可以指向的引用类型就不确定了
    //Student能调用的方法都是自己的或者继承父类的
    Student s1=new Student();
    //Person父类型，可以指向子类，但是不能调用子类独有的方法
    Person s2=new Student();//父类的引用指向子类
    Object s3=new Student();

    //能执行那些方法，主要看对象左边的类型，与右边关系不大
    s2.run();//子类重写了父类，就执行子类方法
    s1.run();
    //s2.eat();

}

/*
多态注意事项：
1.多态是方法的多态，属性没有多态
2.父类和子类，有联系  String Person类型转换异常：ClassCastException
3.多态存在的必要条件：继承关系、方法需要重写、父类的引用指向的是子类的对象father f1=new Son();
不能被重写的方法：
1.static 方法属于类，它不属于实例
2.final常量
3.private方法
 */

p72instanceof和类型转换

判断一个对象是什么类型

instanceof:

//System.out.println(X instanceof Y);能不能编译通过是判断X和Y有没有继承（父子关系）

//Object是Student父类的父类
//Object>String
//Object>Person>Teacher
//目前：Object>Person>Student
Object object = new Student();
System.out.println(object instanceof Student);//true
System.out.println(object instanceof Person);//true
System.out.println(object instanceof Object);//true
System.out.println(object instanceof Teacher);//false
System.out.println(object instanceof String);//false
/*
输出：true
     true
     true
     false
     false

        Process finished with exit code 0

 */
System.out.println("======================================");
Person person = new Student();
System.out.println(person instanceof Student);//true
System.out.println(person instanceof Person);//true
System.out.println(person instanceof Object);//true
System.out.println(person instanceof Teacher);//false
//System.out.println(person instanceof String);//编译器报错
System.out.println("====================================");
Student student  = new Student();
System.out.println(student instanceof Student);//true
System.out.println(student instanceof Person);//true
System.out.println(student instanceof Object);//true
//System.out.println(student instanceof Teacher);//编译器报错
//System.out.println(student instanceof String);//编译器报错

Person obj = new Student();
//student.go();执行不了
//student   将这个对象转换为Student类型，我们就可以使用Student类型的方法了
//Student student=(Student)obj;//高->低
//student.go();
((Student)obj).go();

//类型之间的转换：基本类型转化    高-低
Student student = new Student();
student.go();
Person person=student;//子转父
//子类转换为父类可能丢失自己的本来的方法

子类转换为父类可能丢失自己的本来的方法

/*
类型转换：
1.父类的引用指向子类的对象
2.把子类转换为父类，向上转型（子类转换为父类可能丢失自己的本来的方法）
3.把父类转换为子类，向下转型，需要强制转型
4.方便方法的调用，减少重复的代码！
 */

p73static关键字详解

public class Student {

    private static int age;//静态变量(多线程)
    private double score;//非静态变量

    public void run(){

    }
    public static void go(){
        
    }
    public static void main(String[] args) {
        new Student().run();
        Student.go();
        go();
    }
}

重点理解：

new Student().run();
Student.go();
go();

{
    //代码块（匿名代码块）
}

static
{
    //静态代码块
}

public class Person {

    {
        System.out.println("匿名代码块");
    }
    static
    {
        System.out.println("静态代码块");
    }
    public Person(){
        System.out.println("构造方法" );
    }

    public static void main(String[] args) {
        Person person = new Person();
    }
}
/*
* 执行结果：

静态代码块
匿名代码块
构造方法

Process finished with exit code 0
* */

静态代码块只执行一次

public class Person {

    {
        System.out.println("匿名代码块");
    }
    static
    {
        System.out.println("静态代码块");
    }
    public Person(){
        System.out.println("构造方法" );
    }

    public static void main(String[] args) {
        Person person = new Person();
        System.out.println("==================");
        Person person2=new Person();
    }
}

执行结果：

/*
静态代码块
匿名代码块
构造方法
==================
匿名代码块
构造方法
 */

final之后断子绝孙

p74抽象类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YrBuFwis-1663406306155)(D:\大三上\java自学图片笔记\抽象类.png)]

//abstract关键字：抽象类
public abstract class Action {

    //约束——让别人帮我们实现
    //abstract,抽象方法：只有方法的名字没有方法的实现
    public abstract void deSomething();


}

//继承的抽象类的子类要实现抽象类的所有方法（除非子类也是抽象类）
public class A extends Action{
    public void deSomething(){

    }

}

java中的类只能单继承

但是！！！！

接口可以实现多继承！！！

/*
抽象类特点：
1.不能new抽象类，只能靠子类实现
2.抽象类中可以写普通方法
3.抽象方法必须在抽象类中
抽象的抽象：约束
 */

抽象：提高开发销量，后期可扩展性高

p75接口（可实现继承）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AdbuvCq5-1663406306156)(D:\大三上\java自学图片笔记\接口.png)]

接口就是规范，定义一组规则

接口的本质是契约

在接口中：

public abstract void run(String name);等价于void run(String name);

接口都需要有实现类

接口实现多继承：

//抽象类：extends
//类  可以实现接口 implements
//实现了接口的类，就需要重写接口中的方法
//
public class UserServiceImpl implements UserService,TimeService{


    @Override
    public void run(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void add(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

接口中的常量只要一定义，就是共有静态final常量

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

p76 N中内部类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mWUC59Tb-1663406306156)(D:\大三上\java自学图片笔记\n种内部类.png)]

public class Outer {
    private int id=10;
    public void out(){
        System.out.println("这是外部类的方法");
    }

    class Inner{
        public void in(){
            System.out.println("这是内部类方法");
        }
        public void getID(){//获得外部类的私有属性
            System.out.println(id);
        }
    }

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();//内部类方法
        inner.getID();//获得外部类的私有属性


    }
}

一个java类中可以有多个class类，都是只能有一个public class

public class Outer {

    //局部内部类
    public void method(){
        class Inner{
            
        }
    }

}

public class test {
    public static void main(String[] args) {
        //没有名字去初始化类,不用将实例保存在变量中
        new Apple().eat();

        UserService userService = new UserService() {
            @Override
            public void hello() {
                
            }
        };

    }
}

class Apple{
    public void eat(){
        System.out.println("1");
    }
}

interface UserService{
    void hello();
}

p77异常机制exception

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TOjnBYIK-1663406306157)(D:\大三上\java自学图片笔记\异常.png)]

被除数不能为0的异常：

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

异常抛出：

/*
Exception in thread "main" java.lang.ArithmeticException: / by zero
   at com.exception.Demo01.main(Demo01.java:5)
 */

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dfMY9sqK-1663406306158)(D:\大三上\java自学图片笔记\异常2.png)]

异常处理框架:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3fopaCHY-1663406306158)(D:\大三上\java自学图片笔记\yichang3.png)]

error:一般是内存溢出or栈溢出

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LyA5TH8O-1663406306159)(D:\大三上\java自学图片笔记\error.png)]

exception：一般又程序逻辑错误引起的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eR5GpxsF-1663406306159)(D:\大三上\java自学图片笔记\异常3.png)]

p78获取和抛出异常

重点

抛出异常
捕获异常
异常处理的五个关键字：
try、catch、finally、throw、throws

public static void main(String[] args) {
    int a=1;
    int b=0;
    try {//try监控区域：try中有异常程序可以捕获的到
        System.out.println(a/b);
    }catch (ArithmeticException e) {//捕获异常
        System.out.println("程序出现异常，变量b不能为0");
    } finally {//处理善后工作
        //无论程序出不出现异常，都会执行finally里的话
        System.out.println("finally");
    }
    
}

重点：

try监控区域：try中有异常程序可以捕获的到
catch：捕获异常
finally：处理善后工作，无论程序出不出现异常，都会执行finally里的话

//finally可以不要，finally进行io、资源的关闭

重点：！！！

**catch (Throwable e) **

//catch()括号中的关键字是想要捕获的异常的类型，Throwable是最高级的异常捕获关键字

假设要捕获多个异常，要从小到大的捕获：

//假设要捕获多个异常，要从小到大的捕获
    try {//try监控区域：try中有异常程序可以捕获的到
        new Test().a();
    }catch (Error e) {//catch()括号中的关键字是想要捕获的异常的类型，Throwable是最高级的异常捕获关键字
        System.out.println("Error");
    }
    catch (Exception e) {
        System.out.println("Exception");
    }
    catch (Throwable e) {
        System.out.println("Throwable");
    }
    finally{
    } {
        System.out.println("finally");
    }
}

快捷键：try+alt+t（自动补全代码）

public class Test {
    public static void main(String[] args) {
        try {
            new Test().test(1,0);
        } catch (ArithmeticException e) {
            throw new RuntimeException(e);
        }
    }
    public void test(int a,int b)throws ArithmeticException{
        if (b == 0) {
            ;//throw：主动抛出异常！！一般在方法中使用
            //假设方法中处理不了这个异常，方法上可以抛出异常
        }
    }
}

throw：主动抛出异常！！一般在方法中使用
假设方法中处理不了这个异常，方法上可以抛出异常

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Tt4hYFeH-1663406306160)(D:\大三上\java自学图片笔记\异常4.png)]

p79自定义异常及小节

用户自定义异常，只需继承exception类即可

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(12);
        }catch (MyException e){
            System.out.println("MyException=>"+e);
        }
    }

//自定义的异常类：（extends Exception）
public class MyException extends Exception{
    //传递数字>10则抛出异常
    private int detail;

    //传递消息构造器
    public MyException( int a) {
        this.detail = a;
    }


    //toString方法打印信息
    @Override
    public String toString() {
        return "MyException{" +
                "detail=" + detail +
                '}';
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DWUka729-1663406306161)(D:\大三上\java自学图片笔记\异常总结.png)]

alt+enter:提示键（用来修改错误）

原文链接：https://blog.csdn.net/yzero11111/article/details/126908090