JAVA SE

JAVA SE

JDK JRE JVM

JDK : JAVA development kit

JRE : Java Runtime Environment

JVM : Java Virtual Machine

Java开发环境搭建

安装JDK

1. 下载JDK8；

2. 同意协议，并下载对应的JDK版本

3. 双击安装JDK

4. 记住安装的路径

5. 配置环境变量

   1. 我的电脑–>右键–>属性
   2. 环境变量–>JAVA_HOME
   3. 配置path变量

6. 测试JDK是否安装成功

   1. 打开cmd
   2. 输入java -version,若出现java的版本，则表示安装成功

hello world

1. 新建一个文件夹
2. 新建一个java文件
   1. 文件后缀名为.java
   2. hello.java
   3. [注意点]系统没有显示后缀名，我们需要手动打开
3. 编写代码

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

4. 

5. 可能遇到的情况

   1. java是大小写敏感的
   2. 尽量使用英文
   3. 文件名和类名必须保持一致，并且首字母保持一致
   4. 符号使用英文的符号

Java基础语法

1.注释

• 书写注释是一个非常好的习惯
• 注释的分类
  1. 单行注释 //我是注释
  2. 多行注释 /我是多行注释/
  3. 文档注释 /** 文档注释 */

2.标识符

• 类名，变量名以及方法名都是标识符

• 关键字
  

• 标识符注意点

  1. 所有的标识符都应该以字母，美元符或者是下划线开始
  2. 首字母之后可以是任意字母。任意数字的组合
  3. 不能使用关键字作为变量名或者是方法名
  4. 标识符是大小写敏感的

3.数据类型

• 强类型语言：要求变量的使用严格符合规定，所有变量要求定义后才能使用（java，c++
  安全性高，但是速度低
  弱类型语言：

• Java的数据类型分为两类：

  1. 基本类型

     

  八大数据类型：int,short,byte,long,float,double,char,boolean

  2. 引用类型： 类 接口 数组
  3. 拓展：（Demo03）
     • 整数拓展：进制 二进制0b 十进制 八进制0 十六进制0x（在数的开头加
     • 浮点数拓展：银行业务怎么表示：使用BigDecimal 数学工具类
     • 字符拓展：所有的字符本质就是数字 Unicode表 0-65536
     • 转义字符：\t —>制表符 \n—>换行 …
     • 对象，从内存分析
     • 布尔值扩展：boolean flag = true; if(flag){}

4.类型转换（Demo04）

• 由于Java是强类型语言，所以要进行有些运算的时候，需要用到强类型转换
  低-------------------------------------->高
  byte,short,char->int->long->float->double
• 在运算中，不同类型的数据先转换为同一类型，然后进行运算
• 强制转换： (类型)变量名 高->低
• 自动转换：低->高
• 注意点：
  1. 不能对boolean类型进行转换
  2. 不能把对象类型转换为不相干的类型
  3. 在把高容量转换到低容量的时候，强制转换
  4. 转换的时候可能存在内存溢出，或者精度问题

5.变量

• 变量就是可以变化的量
• Java是一种强类型语言，每个变量都必须声明其类型
• Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域
• 数据类型：变量名 = 值
• 注意事项：
  1. 每个变量都有类型， 类可以是基本的类型，也可以是引用类型
  2. 变量名必须是合法的标识符
  3. 变量声明是一条完整的语句，因此每一个声明都必须以分号结束
• 变量作用域（Demo05）
  1. 类变量
  2. 实例变量
  3. 局部变量 必须声明和初始化值

     public class Variable{
         static int allClicks = 0;//类变量
         String str = "hello,world";//实例变量
         public void method(){
             int i = 0;//局部变量
         }
     }
     

• 注意点：
  1. 除了基本类型，其余默认值均为null
  2. 布尔值：默认值是false

6. 常量（Demo06）

• 常量：初始化之后不能改变值
• 所谓的常量可以理解成一种特殊的变量，它的值在被设定后，在程序运行过程中不允许被改变

  final 常量名 = 值;
  final double PI = 3.14;
  

• 常量名一般使用大写字符

7.命名规范

1. 所有变量，方法，类名：见名知意
2. 类成员变量：首字母小写和驼峰原则
3. 局部变量：首字母小写和驼峰原则
4. 常量：大写字母和下划线
5. 类名：首字母大写和驼峰原则
6. 方法名：首字母小写和驼峰原则

8.运算符

• 

9.包机制

• 一般利用公司域名倒置作为包名 www.baidu.com —> com.baidu.www
• com.wang.xxxxx

10.JavaDoc文档

• javadoc命令是用来生成自己的API文档
• 参数信息：
  1.@author 作者名
  2.@version 版本号
  3.@since 指明需要最早使用的jdk版本
  4.@param 参数名
  5.@return 返回值情况
  6.@throws 异常抛出情况
• 学会使用IDEA生成JavaDoc文档 https://www.cnblogs.com/tanwei81/p/7610884.html (火狐打开)
• 

Java流程控制

1.Scanner对象(scanner.Demo01 and 02)

• 我们可以使用Scanner类来获取用户的输入
• 基本语法：

Scanner s = new Scanner(System.in);

• 通过Scanner类的next()和nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据
• 使用完Scanner之后要关闭 scanner.close();
• next():
  1. 一定要读取到有效字符后才可以结束输入
  2. 对输入有效字符之前遇到的空白，next()方法会自动将其去掉
  3. 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符
  4. next()不能得到带有空格的字符串
• nextLine()
  1. 以Enter为结束符，也就是说nextLine()方法返回的是输入回车之前的所有字符
  2. 可以获得空白

2.顺序结构

• 语句与语句之间，框与框之间是按从上到下的顺序执行的，由若干个依次执行的步骤执行

3.选择结构

• if单选泽结构（struct/IfDemo01）

if(布尔表达式){
	//布尔表达式为true时执行的语句
}

• if双选择结构（struct/IfDemo02）

if(布尔表达式){
	//布尔表达式为真
} else{
	//布尔表达式为假
}

• if多选择结构（struct/IfDemo03）

if(布尔表达式1){
	//如果布尔表达式1为真
} else if(布尔表达式2){
	//如果布尔表达式2为真
} else if(布尔表达式3){
	//如果布尔表达式3为真
} else{
	//如果上述布尔表达式均不为真
}

• 嵌套的if结构

if(布尔表达式1){
	//布尔表达式1的值为true
	if(布尔表达式2){
		//布尔表达式3的值为true
	}
}

• switch多选择结构（struct/SwitchDemo03 04）

1. switch case语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支

switch(expression){
	case value: //语句
		break;
	case value: //语句
		break；
	//可以有任意数量的case语句
	default: //可选
		//语句
}

2. switch语句中的变量类型可以是：
   • byte、short、int或者是char
   • 从Java SE7开始
   • switch支持字符串String类型——JDK 7
   • 同时case标签必须为字符串常量或字面量

循环结构（struct/WhileDemo01）

while循环 do…while循环 for循环

1. while循环（struct/WhileDemo01）

while(布尔表达式){
	//循环内容
}

我们要使循环停止下来，避免死循环
2. do…while循环（struct/DoWhileDemo01）

• 至少执行一次

do{
	//代码语句
}while(布尔表达式)

• while和do-while的区别：（struct/DoWhileDemo02）
  - while先判断后执行，do-while是先执行后判断
  - do…while总是会执行一次的

3. for循环（struct/ForDemo）

for(初始化；布尔表达式；更新){
	//代码语句
}

• for循环语句是支持迭代的一种通用的结构，是最有效，最灵活的循环结构
• for循环的执行次数是在执行前就确定的
• 增强型的for循环
  1. 主要用于数组或集合的

for(声明语句:表达式){
	//代码语句
}

4.break,continue（struct/BreakDemo，Continue）

• break在任何循环的主体部分，均可用break控制循环的流程，break用于强行退出循环，不执行循环中剩余的语句
• continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环体尚未执行的语句，接着进行下一次是否执行循环的判定

5.练习（struct/TestDemo）debug

Java方法

什么是方法？

Java方法是语句的集合，它们在一起执行一个功能

• 方法是解决一类问题的步骤的有序组合
• 方法包含于类或对象中
• 方法在程序中被创建，在其他地方被引用

方法的定义

修饰符 返回值类型 方法名(参数类型 参数名){
	...
	方法体
	...
	return 返回值; 
	//实际参数：实际调用传递给他的参数
	//形式参数:用来定义作用的
}

方法的调用(method/Demo01)

• 调用方法：对象名.方法名
• java支持两种调用方法的方式，根据方法是否返回值来选择
• 当方法返回一个值的时候，方法调用通常被当做一个值，例如：

int larger = max(30,40);

• 如果方法返回值是void，方法调用一定是一条语句
• java是值传递

方法的重载(method/Demo02)

• 重载就是在一个类中，有相同的函数名称，但形参不同的函数
• 方法重载的规则：!!!
  1. 方法名称必须相同!!
  2. 参数列表必须不同(个数不同，或类型不同，参数排列顺序不同等)!!
  3. 方法的返回类型可以相同也可以不同
  4. 仅仅返回类型不同不足以成为方法的重载

命令行传参(method/Demo03)

• 程序在运行的时候再传递给他信息，靠命令行参数给main()函数实现
• 

可变参数(method/Demo04)

• JDK 1.5开始，Java支持传递同类型的可变参数给一个方法
• 在方法声明中，在指定参数类型后加一个省略号(…)
• 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明

public static void printMax(double...  numbers){
	if(numbers.length == 0){
		System.out.println("NO argment 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);
}

递归(method/Demo05)

• 递归结构包括两个部分

1. 递归头：什么时候不调用自身方法，如果没有头，将陷入死循环
2. 递归体：什么时候需要调用自身方法
   能不用递归就不用哦！

数组

数组的定义

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

数组的声明创建(array/Demo01)

• 首先必须声明数组变量，才能在程序中使用数组，下面是声明数组变量的方法：

dataType[] arrayRefVar; //首选
dataType arrayRefVar[];

• java语言使用new操作符来创建数组：

dataType[] arrayRefVar = new dataType arrayRefVar[arraySize];

• 数组的元素是通过索引访问的，数组索引从0开始
• 获取数组的长度：arrays.length

内存分析

• 

• 

三种初始化(array/Demo02)

1. 静态初始化

int[] a = {1,2,3};
Man[] mans = {new Man(1,1),new Man(2,2)};

2. 动态初始化

int[] a = new int[2];
a[0] = 1;
a[1] = 2;

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

数组的基本特点

• 其长度是确定的，数组一旦被创建，它的大小就是不可以改变的
• 其元素必须是相同类型，不允许出现混合类型
• 数组中的元素可以是任何数据类型，包括基本类型和引用类型
• 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的

数组边界

• 下标的合法区间：[0,length-1]，如果越界就会报错

• 

• 

• 小结：

  • 数组是相同数据类型（数据类型可以为任意类型）的有序集合
  • 数组也是对象。数组元素相当于对象的成员变量
  • 数组长度的确定的，不可变得。如果越界，则报错ArrayIndexOutofBounds

数组的使用(array/Demo03)

• for-each循环(for循环)
• 数组作方法入参
• 数组作为返回值

多维数组(array/Demo04)

• 多维数组可以看成是数组的数组，比如说二维数组就是一个特殊的一维数组，其每个元素都是一个一维数组
• 二维数组

int a[][] = new int[2][5];

Arrays类

• java.util.Arrays类
• Arrays类中的方法都是static修饰的静态方法

int[] a = {2,53465,564,1231,15435};
        System.out.println(a);

        //打印数组
        System.out.println("打印数组");
        System.out.println(Arrays.toString(a));
        System.out.println("=========");
        //对数组进行排序,升序
        System.out.println("对数组进行排序");
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        System.out.println("=========");
        //对数组进行填充
        System.out.println("对数组进行填充");
        Arrays.fill(a,0);
        System.out.println(Arrays.toString(a));

冒泡排序

• 排序算法，总共有八大排序
• 时间复杂度是O(n^2)
• 代码是两层循环

public class Demo06 {
    public static void main(String[] args) {
        int[] a = {132,432,45,234,65,123};
        sort(a);
    }

    public static void sort(int[] array){
        for (int i = 0; i < array.length-1; i++) {
            Boolean flag = false;
            for (int j = 0; j < array.length-1 - i; j++) {
                if(array[j]>array[j+1]){
                    int temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = true;
                }
            }
            if (flag == false){
                break;
            }
            System.out.println(Arrays.toString(array));
        }
        System.out.println("最终排序");
        System.out.println(Arrays.toString(array));
    }
}

稀疏数组

• 有很多无意义的数据，所以我们就得压缩矩阵，就用稀疏数组
• 稀疏数组的处理方式是：
  - 记录数组一共有几行几列，有多少个不同的值
  - 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模。

package array;

import java.util.Arrays;

public class Demo07 {
    public static void main(String[] args) {
        int[][] array1 = new int[11][11];
        int sum = 0;
        int count = 0;
        array1[1][2] = 1;
        array1[2][3] = 2;
        //输出原始矩阵
        for (int[] ints:array1) {
            for (int antns:ints) {
                System.out.print(antns+"\t");
            }
            System.out.println();
        }
        //计算有多少个非零数
        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);

        //构建压缩矩阵
        int[][] array2 = new int[sum+1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = 2;

        //将不为零的数存入到压缩矩阵中
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1.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");
        }

        //还原矩阵
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        //打印稀疏数组
        System.out.println("还原后的数组为：");
        for (int[] ints:array3) {
            for (int antns:ints) {
                System.out.print(antns+"\t");
            }
            System.out.println();
        }
    }
}

面向对象编程(OOP)

本质：以类的方式组织代码，以对象的组织（封装）数据
三大特性：封装，继承，多态
抽象

• 方法的定义
  • 修饰符
  • 返回类型
  • break（跳出switch，结束循环）和return（）的区别
  • 方法名：注意规范，见名知意
  • 参数列表：（参数类型，参数名）
  • 异常抛出
• 方法的调用：递归
  • 静态方法：static
  • 非静态方法：未加static，要new
  • 形参和实参
  • 值传递和应用传递
  • this关键字

类与对象的关系

• 创建与初始化对象
  • 使用new关键字创建对象
  • 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用
  • 类中构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：
    ①必须和类的名字相同
    ②必须没有返回类型，也不能写void
  • 构造器必须掌握
    ①使用new关键字，本质是在调用构造器
    ②一旦定义有参构造，如果要是用无参构造，无参就必须显示定义
    ③用来初始化值
    alt+insert

public class Demo01 {
    public static void main(String[] args) {
        Person person = new Person();
        Person person1 = new Person("wnagyu",18);
        System.out.println(person1.name);
    }
}

public class Person {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }
}

1. 类与对象
   类是一个模板，对象是一个具体的实例
2. 方法
   定义，调用
3. 对应的引用
   引用的类型：基本类型8个
   对象是通过引用来操作的：栈===》堆
4. 属性：字段field成员变量
   默认初始化：数字：0 0.0
   char:u0000
   boolean:false
   引用：null
   修饰符 属性类型 属性名 = 属性值
5. 对象的创建和使用
   - 必须使用new关键字创造对象。构造器Person wy = new Person()
   - 对象的属性：wy.name
   - 对象的方法：wy.sleep()
6. 类：静态的属性：属性
   动态的行为：方法

封装

• 要求：高内聚，低耦合
  高内聚：就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用
• 封装：禁止直接访问一个对象中数据的实际表示，应通过接口来访问，称为信息隐藏
• 属性私有：get/set
• 意义：1.提高程序的安全性，保护数据
  2.影藏代码的实现细节
  3.统一接口
  4.系统可维护性增加

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("王羽");
        System.out.println(student.getName());
        student.setAge(888);
        System.out.println(student.getAge());
    }
}

public class Student {
    //属性私有
    private String name;
    private int age;
    private String sex;

    //提供一些public的set和get方法
    //get是获得该属性的值
    //set是给属性赋值
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age>120 || age<0){
            this.age = 3;
        }else {
            this.age = age;
        }
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}0

继承

• 继承的本质是对某一批类的抽象
• extands的意思是“扩展”，子类是父类的扩展
• Java中类只有单继承，没有多继承
• 继承是类和类之间的一种关系。
• 继承关系的两个类，一个为子类，一个为父类。子类继承父类，使用关键字extends来表示
• 子类和父类之间有is a的关系
• 子类继承了父类就会拥有父类的全部方法public
• 在java中，所有的类都是默认直接继承或者间接继承object

public class application {
    public static void main(String[] args) {
        student student = new student();
        student.say();
    }
}

public class student extends Person{
    
}

public class Person {

    //ctrl+h
    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;
    }
}

super详解

• 私有的东西无法被继承
• super注意点：
• super调用父类的构造方法，必须在构造方法的第一个
• super必须只能出现在子类的方法或者构造方法中
• super和this不能同时动用构造方法
• vs this
  • 代表的对象不同：
    this：本身调用者这个对象
    super：代表父类对象的应用
  • 前提:
    this:没有继承也可以使用
    super：只能在继承条件才可以使用
  • 构造方法：
    this():本类的构造
    super():父类的构造

public class Person {
    protected String name = "wangyu";
    public Person() {
        System.out.println("父类构造方法");
    }

public class student extends Person{
    public student() {
        System.out.println("wo是儿子");
    }
}

public class application {
    public static void main(String[] args) {
        student student = new student();
    }
}

运行结果：

方法重写

• 重写都是方法的重写，和属性无关
• 父类的引用指向了子类
• 重写只跟非静态方法有关（即跟static无关）
• 重写的关键词只能是public
• 需要有继承关系，子类重写父类的方法
• 对象能执行哪些方法，主要看对象左边的类型，和右边的关系不大
• 方法名必须相同
• 参数列表必须相同
• 修饰符：范围可以扩大，但不能缩小public>protected>default>private
• 抛出的异常：范围可以被缩小但不能被扩大
• 子类的方法和父类的方法必须要一致：方法体不同
• 为什么需要重写？
  • 父类的功能子类不一定需要或者不一定满足
  • alt+insert :override

public class Person {
    public void say(){
        System.out.println("王羽是个小可爱");
    }
}

public class Student extends Person{

    //override：重写
    @Override
    public void say() {
        System.out.println("王羽是仙女");
    }
}

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

        Student student = new Student();
        student.say();

        Person student1 = new Student(); //子类重写了父类的方法
        student1.say();
    }
}

运行结果：

多态

• 动态编译：类型：可扩展性
• 多态是方法的多态，属性没有多态
• 父类和子类有联系
• 多态存在的条件：继承关系，方法需要重写，父类引用指向子类对象
• 什么不能重写？？？
  • static方法，属于类，它不属于实例
  • final常量
  • private方法

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        Person s2 = new Student();
        Object s3 = new Student();

        s1.run();
        s2.run();
    }
}

public class Person {
    public void run(){
        System.out.println("run");
    }
}

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

运行结果：

instanceof 和类型转换

• instanceof

public class Application {
    public static void main(String[] args) {
        Object object = new Student();
        //object>String
        //object>person>student
        //object>person>teacher

        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
        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);//编译即报错
    }
}

public class Person {

}

public class Student extends Person {
   
}

public class Teacher extends Person {

}

• 父类引用指向子类的对象
• 把子类转换为父类，向上转型
• 把父类转换为子类，向下转型，强制转换
• 方便方法的调用，减少重复额代码，简洁

static关键字详解

public class Student {

    private static int age = 100;
    private String name = "wangyu";

    public void run(){

    }
    public static void go(){

    }

    public static void main(String[] args) {
        System.out.println(Student.age);//直接调用
        System.out.println(new Student().name);
        Student.go();//直接调用
        go();//直接调用
        new Student().run();
    }
}

• 代码块

public class Person {
    
    //2.
    {
        System.out.println("匿名代码块");
    }   
    
    //1. 只执行一次
    static{
        System.out.println("静态代码块");
    }
    
    //3.
    public Person() {
        System.out.println("构造方法");
    }

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

运行结果：

• 静态导入包

//静态导入包
import static  java.lang.Math.random;
import static java.lang.Math.PI;

public class Test {

    public static void main(String[] args) {
        System.out.println(random()); //生成随机数
        System.out.println(PI);
    }
}

运行结果：

抽象类

• abstract修饰
• 不能new出来，只能靠子类去实现它
• 抽象类中可以写普通方法
• 抽象方法必须在抽象类中
• 抽象的约束
• 抽象类：提高开发效率

接口的定义与实现

• 约束和实现分离：面向接口编程
• 接口中的所有定义其实都是抽象的public abstract
• 类可以实现接口inplements接口，实现了接口的类，就必须重写接口的方法
• 定义了一些方法，让不同的人去实现
• 接口不能被实例化，接口中没有构造方法
• 一个java类中可以有多个java类，但是只能有一个public类

public interface UserService {
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

public class UserServiceImpl implements UserService {
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }
}

内部类

• 成员内部类

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

    public class Inner{
        public void in(){
            System.out.println(id);
            System.out.println("这是一个内部类");
        }
    }
}

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.in();
    }
}

异常机制 Exception

• 异常处理框架
• 检查性异常
• 运行时异常
• 错误ERROR
  小结：error和exception的区别：error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，java虚拟机一般会选择终止线程；exception通常是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常

异常处理机制

• try,catch,finally，throws,throw
• try是监控区域，catch（想要捕获的异常类型）是捕获异常，finally是处理善后工作
• 假设要捕获多个异常，需要从小到大去捕获

public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;

        try {
            System.out.println(a/b);
        }catch (Exception e){
            System.out.println("b不能为0");
            e.printStackTrace();
        }finally {
            System.out.println("finally");
        }
    }
}

自定义异常

public class MyException  extends Exception{
    private int detail;

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

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

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

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