开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> java基础小结 -> 正文阅读

[Java知识库]java基础小结

JAVA基础语法

注释，标识符与关键字

1，注释

单行注释
```
//这是一行单行注释
```
多行注释
```
/*这是
  一行
  多行注释*/
```

文档注释

//javaDoc:文档注释 /**   */
/**
 *@Description HelloWorld
*/

2，标识符

标识符也就是在java中的名字（变量名，方法名，文件名等）

由数字，字母，下划线和美元符号组成
不能以数字开头
关键字不能作为标识符
中文也可以作为标识符
一般不要用拼音会显得很廉价
命名规则：见名知意

3，关键字

java中所有关键词

在这里插入图片描述

数据类型

在这里插入图片描述

基本数据类型

整数型
字符型
浮点型
Boolean型

引用数据类型

类
数组
接口

数据类型的拓展

整数型：进制的拓展
浮点型：最好不要使用浮点数进行比较
字符型：

布尔型：精简化

boolean flag = true;
if(flag==true){}//新手
if(flag){}//老手，更加精简化，但意思表达相同
//less is more

转义字符

//\t 制表符，也就相当于一个tab键
//\n 换行符

因为new会创建一个新的对象，并且给做这个对象一个新的内存，而不new，则占用的还是原来的内存，==比较的也就是内存是否相等。

类型转换

java是强语言类型，在基于一些运算时，需要用到类型转换

在运算中不同类型的数据需要先转换为同一类型，然后再进行运算
强制类型转换
- 由高转低
自动类型转换
- 由低转高
不能把布尔值进行转换
不能把对象类型转换成不相干的类型
高转低，强制类型转换
在转换时，要注意内存溢出，或者精度问题（也就是把小数点后面的省略掉）
JDK7的新特性，数字之间可以使用下划线进行分割10_0000_0000

变量，常量，作用域

1，变量

type varName [=value][{,varName[=value]}];
//数据类型 变量名 = 变量值，变量值
//也就是说可以用逗号分隔开多个同类型的变量值
//可以变化的量

2，常量

特殊的变量，一旦设定一个值都就允许改变

final 常量名 = 值;
final double PI = 3.14;
double final PI =3.14;
//final是一个修饰符，不存在先后顺序
//常量名一般是大写

变量的命名规范

3，作用域

类变量：从属于类
实例变量：从属于对象
局部变量：从属于方法

在这里插入图片描述

基本运算符（优先级）

算术运算符：+ ,-,*,/,%.++,–

i++,i--
//先赋值，后自增，自减
++i,--i
//先自增，自减，后赋值

赋值运算符：=
关系运算符：>, <, >=, <=, ==, !=

逻辑运算符：&&，||, !

//&&:都为真则为真，若第一项为假，则会发生短路，后面的一项则不会执行
//||:

位运算符：&， |，^, ~, >>, <<, >>>

<< 表示*2 >>表示/2

条件运算符：(三元运算符)？：

x ? y : z
    //若x为真，则返回y，若为假，则返回z

拓展赋值运算符：+=，-=，*=，/=

字符串连接符： +

在加好的两侧，只要有一侧出现字符串类型，就会将其凭借i起来

System.out.println(" "+a+b);
//这里会将这三个直接拼接起来
System.out.ptrintln(a+b+" ");
//这楼里会将a与b先相加，然后再与后面的自符串拼接起来

幂运算：使用math方法

double pow = Math.pow(3,2);
//3的2次方

包机制

便于更好的管理

JavaDoc生成文档

在这里插入图片描述

使用idea生成javadoc文档

https://blog.csdn.net/qq_42658739/article/details/102531538

java流程控制

用户交互Scanner

用来或取用户输入，进行人机交互

import java.util.Scanner;
public class Demo1 {
    public static void main(String[] args) {
        //创建的是一个扫描器，用来接受用户键盘输入的数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用nextLine方法接收：");

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

        //节省资源,凡是属于IO流的类如果不关闭就会一直占用资源
        scanner.close();

    }
}
/*
关于next与nextLine方法接收键盘输入的区别：
next方法在接收时，在用户输入的内容中遇到空格就会断掉，只会显示空格之前的内容，使用较少
nextLine方法，会等待用户输入完，用户按下回车键才会返回打印出用户输入的内容
*/

/*
从键盘输入不同类型的数
nextInt:输入整数
nextFloat:输入小数
*/

顺序结构

从上而下执行

选择结构

1，if

if(条件){
    语句；
}else if(条件){
    语句；
}
else{
    语句；
}
//嵌套循环
//可以在if中嵌套if

2，switch

switch(expression){
    case value :
        //语句；
        break;
    case value :
        //语句；
        break;
    default:
        //语句；
}
//switch支持字符串String类型

循环结构

while(条件){
	//语句体；
}

//至少能把语句循环一次
do{
    
}while（条件）
    
//最有效，最灵活，最通用的循环结构 
for(i=0;i<=100;i++){
    
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vsINnmC9-1638778128364)(C:\Users\86187\Desktop\JSP速成\images\流程控制\for语句.png)]

增强型for循环

/*
for(声明语句：表达式){
    //代码句子
}
*/
public class Demo1{
    public static void main(String[] args){
        //定义一个数组
        int[] number = {10,20,30,40,50};
        //通过增强型for语句遍历这个数组
        for(int x:number){
            System.out.println(x)
        }
}
    
}

跳出循环

break:跳出整个循环，不再循环，直接执行循环结束后的语句
continue:跳出本次循环，继续下一次循环
goto语句

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fc393Y2H-1638778128365)(C:\Users\86187\Desktop\JSP速成\images\流程控制\goto关键字.png)]

练习

打印九九乘法表

package com.zhihui.base;

public class Demo3 {
    public static void main(String[] args){
        //打印出九九乘法表
        for(int i=1;i<10;i++){
            for(int j=1;j<=i;j++){
                System.out.print(j +"*"+ i +"="+(i*j)+" ");
            }
            System.out.println(" ");
        }
    }
}

打印出下图：

? 。

? 。。。

? 。。。。。

。。。。。。。

? 。。。。。

? 。。。

? 。

package com.zhihui.base;

public class Demo4 {
    public static void main(String[] args){
        //打印一个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();
        }
        for(int k=2;k<=5;k++){
            for(int y=1;y<=k;y++){
                System.out.print(" ");
            }
            for(int x=5;x>=k;x--){
                System.out.print("*");
            }
            for(int z=5;z>k;z--){
                System.out.print("*");
            }

            System.out.println();
        }

    }
}

JAVA方法

什么是方法

1，方法的定义

方法也就是一段用来完成特定功能的代码片段
方法包含在类中

注意：main方法时刻保持干净整洁，尽量将公共的模块都通过方法调用的方式放在外面

//编写一个加法的方法
public class Demo5{
	public static void main(String[] args){
        int sum = add(3,5);
            System.out.println(sum);
    }
    
    //加法方法
     //修饰符 返回值类型 方法名（参数类型 参数名） 
    public static int add(int a,int b){
        //方法体
        //返回值
        return a+b;
    }
}

方法包括：一个方法头和一个方法体
- 修饰符
- 返回值类型
- 方法名
- 参数类型
- 方法体

//比较大小的方法
    public static int max(int num1,int num2){
        int result = 0;
        if(num1>num2){
            result=num1;
        }else if(num1==num2){
            System.out.println(num1+"与"+num2+"相等");
            return 0;

        }else{
            result=num2;
        }
        return result;
    }

}

2，方法的调用

调用方法：对象名.方法名（实参列表）
方法返回值时：方法调用通常被当作一个值
方法返回void，则方法调用一定是一条语句

方法重载

再一个类中，有相同的函数名称

规则

方法名称相同
参数列表必须不同（参数个数不同或者类型不同，参数排列顺序不同等）
方法返回类型可相同也可以不同

仅仅返回类型不相同不构成方法重载

    //加法方法
    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 double add(double a,double b){
        return a+b;
    }
    //方法重载（参数顺序不同）?????
    public static int add(int b,int a){
        return b+a;
    }

}

命令行传参（了解）

在运行一个程序时再传递消息给他，这需要靠传递命令行参数main()函数实现

public class Demo6{
	public static void main(String[] args){
        //args.lenght数组长度
        for(int i=0;i<args.length;i++){
			System.out.prntln("args["+ i +"]:" + args[i]);
        }
    }
}

可变参数

不定向参数

一个方法中只能指定一个可变参数，且他必须是方法的最后一个参数

//无数个参数相加
    public static int add(int...args){
        int result =0;
        for(int i = 0;i<args.length;i++){
            result += args[i];
        }
        return  result;

    }

package com.zhihui.base;

public class Demo6 {
    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("No argument passed");
            return;
        }

        double result = numbers[0];

        //排序
        for(int i =1;i<numbers.length;i++){
            if(numbers[i] > result){
                result = numbers[i];
            }
        }
        System.out.println("The max value is "+ result);
    }
}

递归

递归就是自己调用自己

递归结构包括两个部分
- 能不用就不用，会占内存

数组

数组的概述

相同类型的有序集合
每个数据称作一个数组元素，每个数组元素可以通过一个下表来访问他们

数组的使用

//声明，创建数组
package com.kuang.zhihui;
public tatic void main(String args[]){
    
    //创建了一个新的名叫nums的数组，nums数组空间中有10个小的空间
    int[] nums = new int[10];
    
    //数组是用过索引来赋值
    nums[0] = 1;
    nums[1] = 2;
    nums[5] = 4;
    
    //没有赋值的会有一个默认值
    System.out.println(nums[9]);
    System.out.println(nums[5]);
}
//获取数组长度array.length

1，JAVA内存分析

堆：new的对象和数组
栈：存放基本变量类型和引用对象的变量
方法区：包含所有的class和static变量

2，三种初始化状态

静态初始化
```
//创建+赋值
int[] a={1,2,3,4,5};
```

动态初始化

//动态初始化：也就是自己后面赋值
//可以随时初始化
int[] b = new int[10];
int[0] = 1;

数组的基本特点：
- 数组是相同数据类型的有序集合
- 元素可以是任何数据类型，但一个数组中的元素必须是相同类型
- 数组变量属于引用类型，数组也可以看成对象，数组对象本身就是保存在堆中的
数组边界
- 不能超过数组边界
- 数组越界报错
```
ArrayIndexOutOfBoundsException:数组下标越界
```

多维数组(了解)

也就是数组的数组

//二维数组写法,这是一个两行五列的数组
int[][] array ={2,5}
//arrays[0]---->(2,3)
//arrays[0][0]---->2
int[][] arrays ={(2,3),(3,4),(4,5),(5,6)}

Arrays类

数组的工具类java.util.Arrays，都是人写的
Arrays.toString(数组名)：这个方法可以直接打印出数组
Arrays.sore(数组名)：这个方法可以把数组升序排列
Arrays.fill(数组名)：数组填充

冒泡排序

时间复杂度为O(n2)

package com.zhihui.base;

import java.util.Arrays;

public class Demo11 {
    public static void main(String[] args) {
        //冒泡排序
        //这个程序在循环遍历到i=3时，排序已经完成，但这个程序不会输出
        //仍然会继续循环到i=7不能进入循环后才完成输出
        //所以可以进一步优化
        int[] array={1,11,2,34,54,4,8};
        for(int i=0;i<array.length-1;i++){
            boolean result = true;
            for(int j=0;j<array.length-1;j++){
                int temp =0;
                if(array[j]>array[j+1]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    result = false;
                }
            }
            //优化
            //为了优化冒泡排序，可以通过一个判断来研究数组时否已经排好序了
            // 如果已经排好序，就可以直接break结束循环
            if(result){
                break;
            }
        }
        System.out.println(Arrays.toString(array));
    }

稀疏数组(数据结构)

当数组中大部分元素是0，或者为同一值的数组时，可以使用稀疏数组来保存该数组
稀疏数组的处理方式
- 记录数组一共有几行几列
- 把具有不同值的数组和行列以及值记录在一个小规模的数组中，从而缩小程序的规模

package com.zhihui.base;

import java.util.Arrays;

public class Demo12 {
    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] = 2;
        //输出原始的数组
        System.out.println("输出原始数组");
        for(int[] ints :array1){
            for (int anInt :ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        //转换为稀疏数组
        //获取有效值的个数
        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];

        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("还原");
        //读取稀疏数组
        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(int[] ints :array3){
            for (int anInt :ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

    }
}

java面向对象

java的核心思想就是OOP

什么是面向对象

面向过程：步骤清晰，注重第一步做什么，第二步做什么…，适合处理一些比较简单的问题
面向对象：注重将要解决的问题分类，
- 本质：以类的方式组织代码，以对象的方式组织（封装）对象
- 三大特征：
  - 封装
  - 继承
  - 多态
对于处理复杂的事物，可以使用面向对象来分析整个系统，但涉及到具体的微观操作，任然需要面向过程的思路去处理

方法的加深

方法的调用：
- 静态方法 static：类名.方法名（）；
- 非静态方法 void:实例化类：对象类型对象名 = 对象值
- 值传递与引用传递：

对象的创建与分析

创建对象：使用new创建对象
类：类就是一个单纯的类，类中只包括属性和方法
- 类实例化后就是一个具体的实例

创建对象的内存分析：

public clss Application{
    public static void main(String args[]){
        Pet dog = new pet();
        
        dog.name = "腾辉";
        dog.age = 20;
        dog.shout();
        
        System.out.println(dog.name);
        System.out.println(dog.age);
        
        Pet cat = new Pet();
        cat.name = "腾腾";
        cat.age = 19;
        cat.shout();
    }
}

在这里插入图片描述

*构造器（构造方法）

alt+insert 生成构造器
方法名与类名相同，并且没有返回值
在类中，一旦有了有参构造，无参构造就必须显式定义
作用
- new本质就是调用构造方法
- 初始化对象的值
关于this. 这个一啊不能是?这个类中的 =后面的一般是参数传进来的值

小结

1，类与对象：类是一个模板，是抽象的；对象是一个具体的实例
2，方法的定义与调用
3，对象的引用：引用类型：除开八大基本类型的其他类型
- 对象是通过引用来操作的：栈---->堆
4，属性：字段成员变量默认初始化
- 修饰符属性类型属性名=属性值！
对象的创建与使用
- 必须使用new 关键字创造对象，构造器 Person zhihui = new Person();
- 对象的属性 zhihui.age
- 对象的方法 zhihui.sleep()
类：
- 静态的属性属性
- 动态的行为方法

OOP的三大特性

封装

高内聚，低耦合
作用
- 提高程序的安全性，保护数据
- 隐藏代码的实现细节
- 统一接口
- 系统可维护增加了

属性私有private，get/set

import com.oop.Student;
public class Application{
    public static void main(String[] args){
        Student s1 = new Student();
        
        s1.setName("智慧");
        
        System.out.println(s1.getName());
    }
}

public class Student{
    //属性私有
    private String name;
    private int id;
    private char sex;
    
    //提供一些可以操控这个属性的方法
    //一些public的get,set方法
    
    //get 获得这个数据
    public String getName(){
        return this.name;
    }
    //set给这个数据设置值
    public void setNmae(){
        this.name=name;
    }
    //alt+insert 可以自动生成get set方法
}

继承

继承就是类与类之间的关系
extands 子类可以继承父类的所有方法具有 is a的关系
ctrl + H 继承树

在java中只有单继承，没有多继承（一个儿子只能有一个爸爸，但一个爸爸可以有多个儿子）

//人类：父类
public class Person{
  
    public void say(){
        System.out.println("说了一句话！")
    }   
}

//学生类
//学生 is 人：派生类，子类
public class Student extends Person{
    //子类继承父类，就可以拥有父类的全部方法以及属性,前提是修饰符都是public
    //四个修饰符：
    //public
    //protected
    //default
    //private
    Student student = new Student();
    student.say();   
}

1，object类

在java中所有的类都默认或者直接间接继承object类

2，super

ctrl + F 查找

//人类：父类
public class Person{
   protected String name = "zhihui";
   
    public void print(){
        System.out.println("Person");
    }
       
}

//学生类
//学生 is 人：派生类，子类
public class Student extends Person{
    private String name = "Jiangzhihui";
    public void print(){
        System.out.println("Student");
    }
    public void test1(){
        //在别的地方调用这个方法,调用的也是本类的方法 输出Student
        print();
        //调用的是本类的方法 输出Student
        this.print();
        //调用父类的方法 输出Person
        //注意私有的东西无法被继承
        super.print();
    }
    public void test(String name){
        //通过这个方法传递给name的值 江智慧
        System.out.println(name);
        //this所在类的值  Jiangzhihui
        System.out.println(this.name);
        //父类中的name值 zhihui
        System.out.println(super.name);
    }   
}

//测试类
public class Applicaton{
    public static void main(String[] args){
        Student student = new Student();
        student.test(name:"江智慧");
        student.test1()
    }
}

在这里插入图片描述

3，方法重写

重写都是方法的重写，与属性无关

public class A extends B{
    //Override 重写
    @Override//有注释的功能
    public void test(){
        System.out.println("A=>test");
    }
    
}

public class B{
    public void test(){
        System.out.println("B=>test");
    }
    
}

//测试类
public class Application{
    //静态方法与非静态方法是不一样的
    public static void main(String[] args){
        //静态方法的调用只和左边定义的数据类型有关
        //重写只跟非静态方法有关
        //重写的关键词只能是public，不能私有
        A a = new A();
        a.test();//输出A=>test
     
        //父类的引用指向子类
        B b = new A();//子类重写了父类方法
        b.test();//输出B=>test
        
    }
}

小结

多态

同一方法可以根据发送对象的不同而采取多种不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用类型有很多种

可以实现动态编译：类型：可扩展性

public class Person{
    
}

public class Student extends Person{
    @Override
    public void run(){
		System.out.println("son");
    }
    
}

public class Application{
    public static void main(String[] args){
        //一个对象的实际类型是确定的
        //new Student
        //new Person
        
        //可指向的引用类型不确定
        //student能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        //person父类型，可以指向子类，但不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();
        
        s2.run();//子类重写了父类的方法，执行子类的方法
        s1.run();
        
        
    }
}

多态注意事项
- 多态是方法的多态，属性没有多态性
- 父类与子类，有联系类型转换异常
- 多态存在条件
  - 有继承关系
  - 子类重写父类方法
    - 不能重写的方法，也就不能实现多态，如下三种
    - static 方法，属于类，不属于实例
    - final 常量
    - private方法
  - 父类引用子类对象 father f1 = new son();
instanceof 类型转换引用类型之间的转换
- 判断两个类之间是否有父子关系，是否有联系
```
System.out.println(object instanceof Student);
//判断object是否是Student类
```
小结
- 父类引用指向子类的对象
- 把子类转换为父类，向上转型
- 父类转换为子类，向下转型，强制转换
- 方便方法的调用，减少重复的代码，简介
- 封装继承多态抽象类接口：比抽象类更抽象的

***static关键字

public class Student{
    private static int age;
    //静态变量，一般建议直接使用类名点变量来使用
    private double score;
    //非静态变量，一般使用对象名点变量名来使用
    
    //非静态方法，必须要使用对象点方法来使用
    //非静态方法可以调用静态方法中所有的东西
    //但静态方法只能调用静态方法里面的东西
    public void run(){
        
    }
    //静态方法，可以直接使用类名点方法就可以使用
    //可以连类名都不要也可以使用
    public static void go(){
        
    }
}

//静态代码块
public class Person{
    //2:赋初值
    {
        System.out.println("匿名代码块")
        //匿名代码块
        //创建对象时自动创建，而且再构造器之前
    }
    //1：只执行一次
    static{
        System.out.println("静态代码块")
        //静态代码块
        //跟着类一加载就执行，永久的，只执行一次
    }
    
    //3
    public Person(){
        System.out.println("构造方法")
        
    }
}

//被final定义的类，不能被继承，断子绝孙

*抽象类与接口

1，抽象类

abstract修饰的类
java的类是单继承的，没有多继承，但java中的接口可以多继承
也就是说抽象类只能通过extends去继承，是单继承的

public abstract class Action{
    
    //约束~有人帮我们实现
    //abstract,抽象方法，只有方法名字，没有方法的实现
    public abstract void doSomething();
    
    //1，不能new出来，只能靠子类去实现：约束！
    //2，抽象类中可以写普通方法~
    //3，抽象方法必须在抽象类中
    //抽象的抽象：约束~
   
  
}

2，接口

普通类：只有具体的实现
抽象类：具体实现的规范（抽象方法）都有！
接口：只有规范，自己无法写方法_{专业的约束，可以实现约束和显示分离：面向接口编程}
接口都需要有实现类，实现类的名字一般都是用impl
接口也就是规范，定义的是一组准则，其本质是契约，面向对象的精髓就是对对象的抽象，最能体现这一点的就是接口
声明类的关键字是class 声明接口的关键字是interface
类可以实现接口 implements

实现了接口的类，就要重写接口的方法

//接口1
//这样就从侧面实现了多继承
public interface UserService,TimeService{
    //在接口中，定义的属性都是常量
    int age =99;
    //接口中所有东西都是抽象的public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
    
}

//接口2
public interface TimeService{
    //接口中所有东西都是抽象的public abstract
    void timer();
}

//实现类
public class UserServiceImpl implements UserService{
}

小小结

在这里插入图片描述

内部类

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

成员内部类
静态内部类

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

异常机制（Exception）

1，什么是异常

异常就是在完成一件事时，能够可预见会发生的错误，我们可以通过这种可预见性，来准备相应的解决措施，来防范该异常的发生

检查性异常
运行时异常
错误error：不是异常，是脱离程序员控制的问题

异常体系结构

在这里插入图片描述

java异常处理机制

抛出异常try
捕获异常catch
如果需要捕获多个异常：从小到大
ctrl+alt+t

throw 主动抛出异常，假设方法中处理不了异常，在方法上抛出异常

public class Text{
    public static void main(String[] args){
        int a = 1;
        int b = 0;
        
        try{//发现异常
            System.out.println(a/b);
        }catch(ArithmeticException e){//捕获异常
            System.out.println("程序中变量b作为分母不能为0");
       }finally{//处理善后工作，可以不要，但I/O资源需要关闭
            System.out.println("finally");
        }
    }
}