Java学习笔记

语雀上的笔记：
https://www.yuque.com/woyouguaitutu/fzr9ey/vlthxw

**

一、Java学习随记。

**

1.基本数据类型。1字节=八位

public class Demo1 {
    public static void main(String[] args) {
        //八大基本数据类型
        //整数
        int num1=10;//最常用
        byte num2=20;
        short num3=300;
        long num4=10L;//long 类型后面加个L用于区分
        //小数
        float num5=1.1F;//float类型后面加F
        double num6=3.1415926;
        //字符
        char name='中';
        //字符串，String不是关键字，是类！
        //string name1="XXX";
        //布尔值：是非
        boolean flag=true;
        //boolean flag=false;
    }
}

2.整数、浮点数、字符型、布尔值扩展

public class Demo2 {
    public static void main(String[] args) {
        //整数扩展，进制问题， 二进制0b，十进制，八进制，十六进制
        int i=10;
        int i2=010;
        int i3=0x10;//0-9 A-F
        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println("===============");
        //float  有限  离散 大约数 接近但不等于
        // double
        //比较时，尽量避免使用浮点数进行比较
        //银行业务怎么表示？ 钱？
        //BigDecimal  数学工具//类
        float f=0.1F;
        double d=1.0/10;
        System.out.println(f);
        System.out.println(d);
        System.out.println(f==d);//false
        float a1=232323232323232323F;
        float a2=232323232323232323F+1;
        System.out.println(a1==a2);//true
        System.out.println("===============");
        //字符
        char c1='a';
        char c2='中';
        System.out.println(c1);
        System.out.println((int)c1);//强制转换，Unicode 2字节 0-65536//所有字符本质是数字
        System.out.println(c2);
        System.out.println((int)c2);
        char c3='\u0061';//U0000-UFFFF
        System.out.println(c3);
        int c4=23232;
        System.out.println((char)c4);
        System.out.println("===============");
        //转义字符
        System.out.println("===========\t===\n====\b====\'===\"===");
        String s1=new String("hello,world");//对象，地址不相等
        String s2=new String("hello,world");//地址不相等
        System.out.println(s1==s2);
        String s3="hello,world";
        String s4="hello,world";
        System.out.println(s3==s4);
        //布尔值扩展
        boolean flag=true;
        if (flag){
            System.out.println("老手");
        }
        if (flag==true){
            System.out.println("新手");
        }
    }
}

3.简单数据类型进度转换
按精度由低到高排列

byte->short->char->int->long->float->double

3.1当有低精度转换到高精度时，系统会制动转换
例如：float x=100；输出的是x=100.0；
int x=10;
float y;
y=x;
输出结果：y=10.0；
3.2当有高精度转为低精度的时候我们必须使用显示类型转换运算
例如：int x=(int)34.99;
long y=(long)56.66F;
int z=(int)199L;
强制转换会引起精度的缺失。且由高精度转为低精度的时候不能超过其最大范围！
例如：byte a = (byte)128；结果a=-128；
byte b = (byte)(-129)；结果b=127；
float x = 12.4;系统提示错误；
正确：float x = 12.4F;
float x = (float)12.4;
注意：1.不能对布尔类型进行转换。
2.不能把对象类型转换为不相干类型。
3.在把高类型转换为低类型的时候，强制转换！
4.转换的时候可能存在内存溢出，或者精度缺失！
4.输出基本类型数据
System.out.println();输出数据后换行；
System.out.print();输出数据后不换行；
两者()内不可出现换行–回车–否则将无法通过编译，可通过+号连接较长文字。
5.JDK1.5新增了C语言中printf函数类似的数据输出方式。
格式如下：System.out.printf(“格式控制部分”,表达式1,表达式2,表达式3,表达式4);
%d：int型；
%c：char型；
%f：float型；
%s：字符串型；
%md：输出的int型占m列；
%m.nf：输出的float型占m列小数点后保留n位；
6.JDK7的新特性。
数字之间可以加_来分割，但是_不会输出。
例如：int x=100_100_000;
7.if条件分支语句。//与C语言类似，但是()中只能是boolean类型。

if(){
//若干语句;
}
if(){
//若干语句;
}else{
//若干语句；
}
if(){
//若干语句;
}else if{
//若干语句；
}else{
//若干语句;
}

8.switch开关语句。//与C语言相同。

switch(表达式)
{
case 常量值1:
//若干语句;
break;
case 常量值2:
//若干语句;
break;
case 常量值3:
//若干语句;
break;
case 常量值4:
//若干语句;
break;
default:
//若干语句;
}

9.循环语句。//类似C
9.1for循环语句。//最简单的循环语句。
for(表达式1;表达式2;表达式3){
若干语句;
}
9.2while循环语句。
while(表达式){
若干语句;
}
9.3do-while循环语句。
do{
若干语句;
}while(表达式);
10.break、continue、goto语句。
break;语句可以用于跳出循环；
continue;语句可以用于跳出本次循环，进入下一次循环中。
goto;语句用于跳转，但减少使用，容易出问题。
11.变量。
变量是什么：就是可以变化的量。
Java是一种强类型语言，每个变量都必须声明其类型！
Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。
注意：
每个变量都有类型，类型可以是基本类型，也可以是引用类型。
变量名必须是合法的标识符。
变量声明是一条完整的语句，因此每一个生命都必须以分号结尾。
变量作用域：
类变量、实例变量、局部变量。

public class Demo3 {
    //类变量
    static double salary = 2500;
    //属性：变量
    //实例变量，从属于对象；如果不初始化，就会变成默认值，0，0.0，boolean值默认false；
    //除了基本类型，其余的默认值都是null；
    String name;
    int age;
    //main方法
    public static void main(String[] args) {
        int a=1;//局部变量，必须声明和初始化值。
        System.out.println(a);
        //变量类型   变量名字=new Demo3();
        Demo3 demo3=new Demo3();
        System.out.println(demo3.age);
        System.out.println(demo3.name);
        //类变量
        System.out.println(salary);
    }
}

12.常量（Constant）。
final //修饰符，不存在先后。
static final int a = 2;
final static int a = 2;
13.命名规范。
14.字符串拼接问题。
int a=10;
int b=20;
System.out.println(a+b);//30
System.out.println(""+a+b);//1020
System.out.println(a+b+"");//30
15.包机制。//本质文件夹
16.JavaDoc。//Jdk帮助文档
javadoc命令是用来生成自己API文档的！
cmd的javadoc命令！！！
17.Scanner类
next():
1.一定要读取到有效字符后才可以结束输入。
2.对输入有效字符之前遇到空白，next()方法会自动将其去掉。
3.只要输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
4.next()不能得到带有空格的字符串。
nextLine():
1.以Enter为结束符，也就是说nextLine()方法返回的是输入回车之前的所有字符。
2.可以获得空白。
例子：

package Scanner;
import java.util.Scanner;
public class Demo01 {
    public static void main(String[] args) {
        //创建一个扫描对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用next方法接受数据：");
        //判断用户有没有输入字符串
        if (scanner.hasNext()){
            String str = scanner.next();
            System.out.println("输出的字符为："+str);
        }
        //凡是IO流的类如果不关闭会一直占用资源，要养成好习惯就关掉。
        scanner.close();
    }
}

package Scanner;
import java.util.Scanner;
public class Demo02 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用nextLine方法接受：");
        if (scanner.hasNextLine()){
            String str = scanner.nextLine();
            System.out.println("输出的内容为："+str);
        }
        scanner.close();
    }
}

18.顺序结构。
Java的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行。
顺序结构是最简单的算法结构。
语句与语句之间，框与框之间是按从上到下的顺序进行的，它是由若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构。
19.增强for循环。//重点是用来循环数组和循环的。
例子：

int[] num = {10,20,30,40,50};    
for (int x:num){
            System.out.println(x);
}

20.Java方法详解。
System.out.println
类 对象 方法
例子：

package Method;
public class Demo01 {
    //main方法
    public static void main(String[] args) {
        int sum = add(1,2);
        System.out.println(sum);
    }
    //加法
    public static int add(int a,int b){//static 类方法
        return a+b;
    }
}

21.方法的重载。\一个方法名字可以相同，但参数列表（个数、类型、参数）不能相同。
注：重载就是在一个类中，有相同的函数名称，但是形参不同的函数。
例子：

package Method;
public class Demo02 {
    public static void main(String[] args) {
        int large = max(10,20);
        System.out.println(large);
    }
    //比大小
    public static double max(double num1,double num2){
        double result = 0;
        if (num1>num2){
            result = num1;
        }else{
            result = num2;
        }
        return result;
    }
    public static int max(int num1,int num2){
        int result = 0;
        if (num1>num2){
            result = num1;
        }else{
            result = num2;
        }
        return result;
    }
}

22.命令行传参。
。。。。。
23.可变参数。
参数不定向
*在方法声明中。在指向参数类型后加一个省略号(…)。
例子：

package Method;
public class Demo04 {
    public static void main(String[] args) {
        Demo04 demo04 = new Demo04();
        demo04.method(1,2,3,4,5);
    }
    public void method(int x ,int... i){
        System.out.println(x);
        System.out.println(i[0]);
        System.out.println(i[1]);
        System.out.println(i[2]);
        System.out.println(i[3]);
    }
}

24.递归。\自己调用自己。\数过大的时候就有麻烦了，只能调用较小的数。
递归头：什么时候调用自身方法，如果没有头，将陷入死循环。
递归体：什么时候需要调用自身方法。
例子：package Method;
public class Demo05 {
public static void main(String[] args) {
System.out.println(test(5));
}
public static int test(int n){
if (n==1){
return 1;
}else{
return n*test(n-1);
}
}
}
25.数组。
25.1.数组是相同类型数据的有序集合。
数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。
其中，每一个数据称作为一个数组元素，每个数组元素可以通过一个下标来访问它们。
声明：首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法。

int[] nums;//定义1
int nums2[];//定义2

二维数组也是如此。
注意：1.Java不允许在声明数组中的方括号内指定数组元素的个数。
2.构成二维数组的一维数组不必有相同的长度，在创建二维数组的时候可以分别指定构成该二维数组的一维数组的长度。
如下：

int a[][] = new int[3][];
a[0] = new int[6];
a[1] = new int[12];
a[2] = new int[3];

3.和C语言不同的是，Java允许使用int型变量的值指定数组的元素个数；
例如：

int size = 30;
double num[] = new double[size];
package Array;
public class Demo01 {
    public static void main(String[] args) {
        int[] nums;//定义1
        nums = new int[10];
        nums[0] = 1;
        nums[1] = 1;
        nums[2] = 1;
        nums[3] = 1;
        nums[4] = 1;
        nums[5] = 1;
        nums[6] = 1;
        nums[7] = 1;
        nums[8] = 1;
        nums[9] = 1;
        for (int i=0;i<10;i++){
            System.out.println(nums[i]);
        }
    }
}

25.2.length的使用。
数组元素的个数称为数组的长度。
对于一维数组“数组名.length”的值是数组中元素的个数；而，对于二维数组而言“数组名.length”的值是它含有的一维数组的个数。

float a[] = new float[12];
int b[][] = new int[3][4];
a.length = 12;b.length = 3;

25.3初始化。

float boy[] = {21.3f,23.3f,2.2f,45.4f,55.5f}相当于float boy[] = new float[5];然后再逐一赋值。

25.4数组的引用。
数组属于引用类型，因此两个相同类型的数组如果具有相同的引用，它们就必须具有相同的元素。

int a[] = {1,2,3};
int b[] = {4,5};
a = b;

那么数组a中的元素将变成b中的元素，和b[]一模一样。
25.5数组的遍历。
循环遍历
toString()方法遍历。

package Demo;
import java.util.Arrays;
public class Demo09 {
    public static void main(String[] args) {
        char a[] = {'a','b','c','d'};
        for (int n=0;n<a.length;n++){
            System.out.print(a[n]+" ");
        }
        System.out.println();
        for (char ch:a){
            System.out.print(ch);
        }
        System.out.println();
        System.out.println(Arrays.toString(a));
    }
}

26.jdk帮助文档。
27.冒泡算法。

package Array;
import java.util.Arrays;
public class Demo03 {
    public static void main(String[] args) {
        //冒泡排序
    int[] a = {12,34,1,35,33,734,223,45,251,11};
    int[] b = sort(a);
        System.out.println(Arrays.toString(b));
    }
    public static int[] sort(int[] array){
        //外层循环，判断我们这个要走多少次
        int temp = 0;
        for (int i = 0;i<array.length-1;i++){
            for (int j = 0;j<array.length-1-i;j++){
                if (array[j+1]<array[j]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
        return array;
    }
}

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

package Array;
public class Demo04 {
    public static void main(String[] args) {
        //1.创建一个二维数组。2.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);
        //创建稀疏数组
        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");
        }
        //还原
        int[][] array3 = new int[array2[0][0]][array2[0][1]];//11,11
        for (int i = 1; i < array2.length; i++) {//从1开始，因为0存了数据
            array3[array2[i][0]][array2[i][1]] = array2[i][2];//获取array2中存的行列数及所对应的数据！！！
        }
        System.out.println("还原后");
        for (int[] ints:array3){
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}

29.面向对象。
面向对象过程，步骤的细分。
面向对象编程的本质就是：以类的组织代码，以对象的组织（封装）数据。
三大特性：
封装
继承
多态
从认识论角度考虑是先有对象后有类。对象：具体的事物。类：是抽象的，是对对象的抽象
从代码运行角度考虑是先有类后有对象。类是对象的模板。
30.方法。
静态方法 static//可以在main函数里面直接调用。
非静态方法//必须要实例化这个类。就是new一下。
例子：//非静态//求输入字符串的每种字母的个数。

package Demo;
import java.util.Locale;
import java.util.Scanner;
public class Demo14 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str = in.nextLine().toLowerCase(Locale.ROOT);//全部准换为小写，便于判断，也可以转换为大写。大写后下面就需要改变。
        char[] ch = new char[str.length()];
        for (int i = 0; i < ch.length; i++) {
            ch[i] = str.charAt(i);
        }
        new Demo14().chars(ch);
        in.close();
    }
    public void chars(char[] ch){
        int[] count = new int[26];//定义26个数组，分别对应a-z，用来统计不同字母的个数。
        for (char j = 97; j <= 122; j++) {//a-z 的过程。
            for (int i = 0; i < ch.length; i++) {
                if (ch[i]==j){
                    count[j-97]++;//对应字母的个数加一，只能是0-25。要和j相关。25-（122-j）=j-97
                }
            }
        }
        for (int i = 0; i < 26; i++) {
            if (count[i]!=0){
                System.out.println("("+(char)(65+i)+")Num="+count[i]);
            }
        }
    }
}

//静态

package Demo;
import java.util.Locale;
import java.util.Scanner;
public class Demo14 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str = in.nextLine().toLowerCase(Locale.ROOT);//全部准换为小写，便于判断，也可以转换为大写。大写后下面就需要改变。
        char[] ch = new char[str.length()];
        for (int i = 0; i < ch.length; i++) {
            ch[i] = str.charAt(i);
        }
        chars(ch);
        in.close();
    }
    public static void chars(char[] ch){
        int[] count = new int[26];//定义26个数组，分别对应a-z，用来统计不同字母的个数。
        for (char j = 97; j <= 122; j++) {//a-z 的过程。
            for (int i = 0; i < ch.length; i++) {
                if (ch[i]==j){
                    count[j-97]++;//对应字母的个数加一，只能是0-25。要和j相关。25-（122-j）=j-97
                }
            }
        }
        for (int i = 0; i < 26; i++) {
            if (count[i]!=0){
                System.out.println("("+(char)(65+i)+")Num="+count[i]);
            }
        }
    }
}

31.引用传递和值传递。
例子：

package Demo;
//引用传递，对象，本质还是值传递
public class Demo15 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);
        Demo15.change(person);
        System.out.println(person.name);
    }
    public static void change(Person person){
        //person是一个对象：指向的是Person person = new Person();这是一个具体的人，可以改变。
        person.name = "文璐";//属性
    }
}
//定义了一个Person类，有一个属性。
class Person{
    String name;
}

package Demo;
//引用传递，对象，本质还是值传递
public class Demo15 {
    public static void main(String[] args) {
//        Person person = new Person();
        int a=1;
        System.out.println(a);
        Demo15.change(a);
        System.out.println(a);
    }
    public static void change(int a){
        a = 10;
    }
}

32.类与对象的关系。
类：抽象的数据类型，它是对某一类事物整体描述/定义，但是并不代表某一个具体的事物。
对象：是抽象概念的具体实例。
new关键字创建对象。
一个项目只有一个main方法！！
33.this的用法
例子：

package Method;
public class Demo06 {
    public static void main(String[] args) {
    Demo06 de = new Demo06();//创建Demo6的对象。
    de.name = "文璐";//对de里面的name进行赋值
    de.study();//de调用study方法。
    }
    String name;
    int age;
    public void study(){
        System.out.println(this.name+"在学习");//this指的是本类中的。
    }
}

34.构造器
构造器：1.和类名相同。
2.没有返回值。
作用 ：1.new 本质是在调用构造器。
2.初始化对象的值
注意点：1.定义有参构造后，如果想使用无参构造，必须显示的定义一个无参构造。//无参构造不写的话是默认存在的。
IDEA Alt+ins自动生成构造器。

package Application;
public class Application {
    public static void main(String[] args) {
    Person person = new Person("wenlu");
        System.out.println(person.name);
    }
}

package Application;
public class Person {
//一个类即使什么都不写，也会存在一个方法。默认的
    String name;
    //实例初始化值
    public Person(){//无参构造器
        this.name = "文璐"; 
    }
    public Person(String name){//有参构造器，一旦定义了有参构造，无参构造就必须显示定义
        this.name = name;
    }
}

实验结果会根据Person中是否有参数，调用不同的方法，得到不同的结果！！
35.封装
该露的露，该藏得藏。
我们程序设计要求“高内聚，低耦合”。高内聚就是类类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
封装（数据的隐藏）
通常，应禁止直接访问一个对象中的数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
记住：属性私有，get/set

package Application;
public class Student {
    //私有属性
    //名字
    private String name;
    //学号
    private int id;
    //性别
    private char sex;
    //get set
    public String getName(){
        return this.name;
    }
    public void setName(String name){
        this.name = name;
    }
}

私有可以用于判断程序是否合理！！，有的赋值是不合法的，封装后，有的数据不用更变
1.提高程序的安全性，保护数据。
2.隐藏代码的实现细节。
3.统一接口。
4.系统可维护性增加了。

36.继承。
继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
extends的意思是“扩展”。子类是父类的扩展。
Java中只有单继承没有多继承。
继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
子类和父类之间，从意义上来讲应该具有“is a”的关系。
//子类继承了父类就可以继承父类的所有方法。
private不能调用。
可以使用get、set方法来调用private。
object类//在Java中所用的类都默认直接或间接继承object类。

37.super//用于访问父类的元素或方法。
注意点：
1.super调用父类的构造方法，必须在构造方法的第一个。
2.super 必须只能出现在子类的方法或者构造方法中！
3.super和this不能同时调用构造方法！
VS this：
1.代表的对象不同：
this：本身调用这个对象
super：代表父类的这个对象。
2.前提：
this：没有继承也可以用
super：只能在继承条件才能使用
3.构造方法：
this()：本类的构造
super()：父类的构造！
38.方法重写–>多态

package Extend;
public class Demo {
    public static void main(String[] args) {
        A a = new A();
        a.test();//A
        //父类的引用指向了子类
        B b = new A();
        b.test();//B
    }
}

package Extend;
public class A extends B{
    public static void test(){
        System.out.println("A->test()");
    }
}

package Extend;
public class B {
    public static void test(){
        System.out.println("B->test()");
    }
}

//不用static的话效果不一样。
重写：需要有继承关系，子类重写父类的方法！
1.方法名必须相同
2.参数列表必须相同
3.修饰符：范围可以扩大，但是不能缩小：public->Protected->Default->private
4.抛出异常：范围，可以缩小，但是不能扩大：ClssNotFoundExpection–>Exception（大）
重写，子类的方法和父类必要一致：方法体不同!
为什么需要重写？
1.父类的功能子类不一定需要，或者不一定满足要求。
2.alt+insert：override；
39.多态。可动态编译：可扩展性。
1.即同一方法可以根据发送对象的不同而采取不同的行为方式。
2.一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多。
多态存在的条件：
有继承关系
子类重写父类方法
父类引用指向子类对象
注意：多态是方法的多态，属性没有多态。
例如：

Student extends Person
Student s1 = new Student(); //子类能调用的方法，是自己的或者父类的，而父类不能直接调用子类的方法。父类调用子类时，会设计强制转换！！！
Person s2 = new Student(); //父类的医用指向子类的类型
Object s3 = new Student(); //多态，相当于一个类，继承了其他类，其就有多种状态。
((Student) s2).方法//s2调用子类方法的时候。当然，要有父子关系！
不能重写的方法：
static 方法，属于类，不属于实例
final 常量
private 方法

40.instanceof和类型转换。
1.instanceof用于判断是否是父子关系。
X instanceof Y来判断，返回true ，false。
2.类型转换
高转低–强转，低转高–不需要。
例如：将Person类型转换为Student类型
Person obj = new Person();
Student student = (Student) obj;
注意：转换，可能会丢失一些自己的方法。
41.static详解。
static方法在程序加载时就已经加载了，创建对象时只执行一次，知道程序结束。而其他变量，方法，每创建一个对象，就执行一次。
静态导入包：import static java.lang.Math.random;
final 不能被继承
42.抽象类。abstract//父债子偿
abstract ，抽象方法，只有方法名字，没有方法的实现。
public abstract void doSomething();
将由它的子类来完成它的方法体书写。
1.不能new这个抽象类，只能靠子类去实现它。：约束。
2.抽象类中可以写普通方法。
3.抽象方法必须写在抽象类中。
43.接口。
普通类：只有具体实现。
抽象类：具体实现和规范（抽闲方法）都有！
接口：只有规范！自己无法写方法_{专业的约束！约束和实现分离：面向接口编程}
用interface定义。
子类通过implements关键字来实现它，再重写里面的方法。
作用：
1.约束
2.定义一些方法，让不同的人实现
3.public abstract
4.public static final
5.接口不能被实例化，没有构造方法
6.implements可以实现多个接口
7.必须要重写接口中的方法
44.内部类。
内部类就是在一个类的内部再定义一个类，比如，A类中定义一个B类，那么B类相对于A类来说就称为内部类，而A类相对于B类来说就是外部类。
一个java类中可以有多个class类但是只能有一个public class类
1.成员内部类。
例子：

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

package Extend;
public class Demo {
    public static void main(String[] args) {
        //new
        Outer outer = new Outer();
        //通过外部类来实例化内部类
        outer.out();
        Outer.Inner inner = outer.new Inner();
        inner.in();
    }
}

2.静态内部类。
加上static关键字就好
3.局部内部类。

public class Outer {
    private int id;
    public void out(){
        System.out.println("外部类的方法");
        class A{
            public void aaa(){
                System.out.println("sss");
            }
        }
    }
}

4.匿名内部类。
？？？？？
没有名字初始化类？同一的？
45.异常处理机制。
异常处理五个关键字：try，catch，finally，throw，throws
1.抛出异常。
2.捕获异常。
例子：

package Extend;
public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;
        try {//try监控区域
            System.out.println(a/b);
        }catch (ArithmeticException e){//catch 捕获异常，里面的参数是想要捕获的类型。
            System.out.println("程序出现异常，变量b不能为0");
        }finally {//处理善后工作
            System.out.println("finally");
        }
    }
}

可以加多个catch(){}用于捕获多个异常。且错误程度由小到大。
Ctrl+Alt+T快捷键，选中一段代码后，可快速生成代码块包裹。
if (b==0){
throw new ArithmeticException();//主动抛出异常
}
在方法中使用throws主动抛出异常。
返回：
程序出现异常，变量b不能为0
finally
46.自定义异常。
继承Exception类后就是自定义异常类。