记录自己快速熟悉Java基础的历程

一、Java概述

1.1 什么是Java

Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。

1.2 Java三大版本

Java SE（J2SE，Java 2 Platform Standard Edition，标准版）
Java EE（J2EE，Java 2 Platform Enterprise Edition，企业版）
Java ME（J2ME，Java 2 Platform Micro Edition，微型版）

1.3 JVM、JRE和JDK的关系

JVM
Java Virtual Machine是Java虚拟机，Java程序需要运行在虚拟机上，不同的平台有自己的虚拟机，因此Java语言可以实现跨平台。
JRE
Java Runtime Environment包括Java虚拟机和Java程序所需的核心类库等。核心类库主要是java.lang包：包含了运行Java程序必不可少的系统类，如基本数据类型、基本数学函数、字符串处理、线程、异常处理类等，系统缺省加载这个包

只运行java程序的话，只需要安装JRE
JDK
Java Development Kit是提供给Java开发人员使用的，其中包含了Java的开发工具，也包括了JRE。所以安装了JDK，就无需再单独安装JRE了。其中的开发工具：编译工具(javac.exe)，打包工具(jar.exe)等

Java开发环境，就安装JDK，包含JRE等

1.4 Java语言有哪些特点

简单易学（Java的语法与C/C++很接近）
面向对象（封装，继承，多态）
跨平台(.java文件->javac->.class->java通过JVM运行)
解释型语言
Java有自动内存管理机制，不需要程序员手动释放无用内存

1.5 什么是字节码？字节码的好处是什么？

字节码：
Java源代码经过虚拟机编译器编译后产生的文件（即扩展为.class的文件），它不面向任何特定的处理器，只面向虚拟机。
采用字节码的好处：
Java语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特点。所以Java程序运行时比较高效，而且，由于字节码并不专对一种特定的机器，因此，Java程序无须重新编译便可在多种不同的计算机上运行。

1.6 Java程序执行流程

1.7 IDEA常用快捷键

psvm，main方法快捷输入
sout，输出快捷键
Ctrl+d，复制并粘贴当前行
Ctrl+shift+上/下箭头，上下移动代码块
new 后面加.var，自动生成变量名，也可以Alt+Enter
Ctrl+/，单行注释；Ctrl+shift+/，多行注释
Ctrl+Alt+t，添加代码块包裹
Alt+Insert，生成类的常用方法

二、Java基础

2.1 输入输出、数据类型

2.1.1 Hello world

//Hello.java
public class Hello {  
    public static void main(String[] args) {  
        System.out.println("Hello world!");  
    }  
}

源文件名与类名相同
每个类只能有一个main(类的入口方法)
使用//进行注释

2.1.2 基本数据类型

//Variable.java 
public class Variable {  
    public static void main(String[] args) {  
        byte num0=127;  
        short num1=200;  
        int num2=100;  
        long num3=123123123123123123L;  
        float num4=3.14f;  
        double num5=3.14123123123;  
        char ch='a';  
        boolean flag=true;  
        System.out.println("字节类型num0="+num0);  
        System.out.println("短整型num1="+num1);  
        System.out.println("整型num2="+num2);  
        System.out.println("长整型num3="+num3);  
        System.out.println("浮点型num4="+num4);  
        System.out.println("双精度浮点型num5="+num5);  
        System.out.println("字符ch="+ch);  
        System.out.println("布尔值flag="+flag);  
    }  
}

数据类型的转换关系

byte->short->int->long->float->double（精度链/范围链）
上面的链反向需强制类型转换

自动类型转换

//Change_byte.java
public class Change_byte {  
    public static void main(String[] args) {  
        int aInt = 20;  
        long bLong = 50L;  
        double cDouble = 4.8;  
  
        //低优先级类型数据 + 高优先级类型数据 ——> 结果会自动转换为高优先级数据  
        long sum = aInt + bLong;  
  
        //long -> int 需要强制类型转换  
        int d = (int) bLong;  
        //double -> int 需要强制类型转换  
        int e = (int) cDouble;  
  
        System.out.println("自动类型转换 int—>long:  " + sum);  
        System.out.println("强制类型转换 long—>int:  " + d);  
        System.out.println("强制类型转换 double—>int:  " + e);  
        System.out.println();  
  
        //int 和 byte 转换  
        byte fByte = (byte) aInt;  //高转低，强转  
        int gInt = fByte;          //低转高，自动  
        System.out.println("高转低-强转，int->byte:  " + fByte);  
        System.out.println("低转高-自动，byte->int:  " + gInt);  
        System.out.println();  
  
        //int 和 char 转换  
        char hChar = 'a';  
        int iInt = hChar;  
        char j = (char) iInt;  
        System.out.println("低转高-自动，char->int:  " + iInt);  
        System.out.println("高转低-强转，int->char:  " + j);  
        System.out.println();  
  
        //byte 和 char 互转  
        byte m = (byte) hChar;  
        char n = (char) m;  
        System.out.println("char->byte，强转：  " + m);  
        System.out.println("byte->char，强转：  " + n);  
    }  
}

2.1.3 引用数据类型

引用数据类型的内存分布，可以类比C/C++中的指针

数组

一维数组

//Bubble_sort.java  
public class Bubble_sort {  
    public static void main(String[] args) {  
        int n=20;  
        int arr[]=new int[n];  
        Random numList = new Random();  
        for (int i = 0; i <n; i++) {  
            arr[i]= numList.nextInt(100);  
        }  
        int temp=0;  
        for (int i = 0; i< arr.length-1; i++){  
            for (int j=0;j<arr.length-1-i;j++){  
                if (arr[j]>arr[j+1]){  
                    temp=arr[j];  
                    arr[j]=arr[j+1];  
                    arr[j+1]=temp;  
                }  
            }  
            System.out.println("第"+i+"轮");  
            for (int k=0;k<arr.length;k++){  
                System.out.print(arr[k]+"\t");  
            }  
            System.out.println();  
        }  
    }  
}

二维数组

//MiGong.java    迷宫
public class MiGong {  
    public static void main(String[] args) {  
        int arr[][] = new int[10][10];  
        for (int i=0;i<10;i++){  
            arr[0][i]=1;  
            arr[arr.length-1][i]=1;  
        }  
        for (int i=0;i<10;i++){  
            arr[i][0]=1;  
            arr[i][arr.length-1]=1;  
        }  
        arr[3][1]=1;  
        arr[2][2]=1;  
        Tools tools=new Tools();  
        tools.FindWay(arr,2,1);  
  
        for (int i=0;i<arr.length;i++){  
            for (int j=0;j<arr[i].length;j++){  
                System.out.print(arr[i][j]+"\t");  
            }  
            System.out.println();  
        }  
  
    }  
}  
class Tools{  
    public boolean FindWay(int arr[][],int start_i,int start_j){  
        if (arr[arr.length-2][arr.length-2]==2){  
            return true;  
        }else {  
            if (arr[start_i][start_j]==0){  
                arr[start_i][start_j]=2;  
                if (FindWay(arr,start_i+1,start_j))  
                    return true;  
                else if (FindWay(arr,start_i,start_j+1))  
                    return true;  
                else if (FindWay(arr,start_i-1,start_j))  
                    return true;  
                else if (FindWay(arr,start_i,start_j-1))  
                    return true;  
                else{  
                    arr[start_i][start_j]=3;  
                    return false;                }  
            }else {  
                return false;  
            }  
        }  
    }  
}

类
接口

后面讲

2.1.4 输入

导入包import java.util.Scanner;

import java.util.Scanner;
//Print.java  
public class Print {  
    public static void main(String[] args) {  
	    Scanner scanner = new Scanner(System.in);  
	    //接收一个int类型的值并进行输出  
	    System.out.println(scanner.nextInt());  
	    //接收一个double类型的值并进行输出  
	    System.out.println(scanner.nextDouble());  
	    //接收一个boolean类型的值并进行输出  
	    System.out.println(scanner.nextBoolean());  
	    //判断是否还有下一个值,空格符截断  
	    if (scanner.hasNext()){  
	        System.out.println(scanner.next());  
	    }  
	    //判断是否还有下一个值,换行符截断  
	    if (scanner.hasNextLine()){  
	        System.out.println(scanner.nextLine());  
	    }  
	  
	    //IO 流关闭  
	    scanner.close();  
	}  
}

2.2 运算符

2.2.1 算术运算符

//arithmetic.java  
public class arithmetic {  
    public static void main(String[] args) {  
        int a = 10;  
        int b = 5;  
  
        System.out.println(a + b);//15  
        System.out.println(a - b);//5  
        System.out.println(a * b);//50  
        System.out.println(a / b);//2  
        System.out.println(a % b);//0  
  
        b = 3;  
        System.out.println(a + b);//13  
        System.out.println(a - b);//7  
        System.out.println(a * b);//30  
        System.out.println(a / b);//3  类型导致的  
        System.out.println(a % b);//1
		
		System.out.println(10+200);//210
        System.out.println("abc"+"zxy");//abczxy
        System.out.println(100+"2ab");//1002ab
        System.out.println("2ab"+100);//2ab100
    }  
}

2.2.2 关系运算符

//relationship.java  
public class relationship {  
    public static void main(String[] args) {  
        int a = 10, b = 20;  
        System.out.println(a == b); // false  
        System.out.println(a != b); // true  
        System.out.println(a > b); // false  
        System.out.println(a < b); // true  
        System.out.println(a >= b); // false  
        System.out.println(a <= b); // true  
    }  
}

2.2.3 位运算符

//Bitwise_operators.java  
public class Bitwise_operators {  
    public static void main(String[] args) {  
        int a = 60, b = 13;  
        System.out.println("a 的二进制：" + Integer.toBinaryString(a)); // 111100  
        System.out.println("b 的二进制：" + Integer.toBinaryString(b)); // 1101  
  
        int c = a & b;  
        System.out.println("a & b：" + c + "，二进制是：" + Integer.toBinaryString(c));  
  
        c = a | b;  
        System.out.println("a | b：" + c + "，二进制是：" + Integer.toBinaryString(c));  
  
        c = a ^ b;  
        System.out.println("a ^ b：" + c + "，二进制是：" + Integer.toBinaryString(c));  
  
        c = ~a;  
        System.out.println("~a：" + c + "，二进制是：" + Integer.toBinaryString(c));  
  
        c = a << 2;  
        System.out.println("a << 2：" + c + "，二进制是：" + Integer.toBinaryString(c));  
  
        c = a >> 2;  
        System.out.println("a >> 2：" + c + "，二进制是：" + Integer.toBinaryString(c));  
  
        c = a >>> 2;  
        System.out.println("a >>> 2：" + c + "，二进制是：" + Integer.toBinaryString(c));  
    }  
}

2.2.4 二进制

二进制的高位为符号位（0表示整数，1表示负数）
正数的原码、补码、反码都一样(三码合一)
负数的反码=原码符号位不变，其他位取反
负数的补码=反码+1
负数的反码=补码-1
0的反码和补码都是0
计算机在运行时,都是以补码形式运算

结果看原码

import java.util.Scanner;       //导入类

public class Input {
    public static void main(String[] args) {
        int a=2,b=3;
        //a的原码、补码、反码：00000000 00000000 00000000 00000010
        //b的原码、补码、反码：00000000 00000000 00000000 00000011
        //-----------------------------------------------------
        //                 00000000 00000000 00000000 00000010
        //且为正数，故值为2
        
        System.out.println(a&b);//2
        //-a的原码、补码、反码：10000000 00000000 00000000 00000010
        //-a的反码：11111111 11111111 11111111 11111101
        //-a的补码：11111111 11111111 11111111 11111110
        //~-a的补码：00000000 00000000 00000000 00000001
        //符号为0正数，结果为1
        System.out.println(~-a);//1
        
        //a的原码、11111111 11111111 11111111 11111101
        //~a的反码：11111111 11111111 11111111 11111100
        //~a的原码：10000000 00000000 00000000 00000011
        //符号位1负数，结果为-3
        System.out.println(~a);//-3
    }
}

2.2.5 逻辑运算符

//Logical.java  
public class Logical {  
    public static void main(String[] args) {  
        int num1=10;  
        int num2=5;  
        int num3=20;  
        System.out.println(num1<num2&&num1<num3);
        //false && true = false  
  
        System.out.println(num1>num2||num1<num3);
        //true || true = true  
    }  
}

2.2.6 三元运算符

//Ternary.java  
public class Ternary {  
    public static void main(String[] args) {  
        int num1=100;  
        int num2=200;  
        System.out.println(num1>num2?num1:num2);  
    }  
}

2.3 流程控制

2.3.1 if-else

import java.util.Scanner;  
  
//If_else.java 
public class If_else {  
    public static void main(String[] args) {  
        int n;  
        Scanner scanner = new Scanner(System.in);  
        n=scanner.nextInt();  
        if(n%2==0){  
            System.out.println("偶数");  
        }else{  
            System.out.println("奇数");  
        }  
    }  
}

2.3.2 if-elseif-else

import java.util.Scanner;
//If_elseif_else.java  
public class If_elseif_else {  
    public static void main(String[] args) {  
        Scanner scanner=new Scanner(System.in);  
        double score=scanner.nextDouble();  
        if (score>=0&&score<=100){  
            if (score>=90)  
                System.out.println("A级");  
            else if (score>=80&&score<=89)  
                System.out.println("B级");  
            else if (score>=70&&score<=79)  
                System.out.println("C级");  
            else if (score>=60&&score<=69)  
                System.out.println("D级");  
            else                System.out.println("不及格");  
        }else  
            System.out.println("输入有误！");  
    }  
}

2.3.3 switch

import java.util.Scanner;  
//Switch_.java  
public class Switch_ {  
    public static void main(String[] args) {  
        int n;  
        Scanner scanner = new Scanner(System.in);  
        n=scanner.nextInt();  
        switch (n){  
            case 1:  
                System.out.println("星期一");  
                break;            
            case 2:  
                System.out.println("星期二");  
                break;            
            case 3:  
                System.out.println("星期三");  
                break;            
            case 4:  
                System.out.println("星期四");  
                break;            
            case 5:  
                System.out.println("星期五");  
                break;            
            case 6:  
                System.out.println("星期六");  
                break;            
            case 7:  
                System.out.println("星期日");  
                break;            
            default:  
                System.out.println("输入错误");  
        }  
    }  
}

2.3.4 for

import java.util.Scanner;  
//pyramid.java          空心金字塔  
public class pyramid {  
    public static void main(String[] args) {  
        Scanner scanner = new Scanner(System.in);  
        int n=scanner.nextInt();  
        for (int i = 1; i <= n; i++) {  
            for (int k = 1; k <=n-i ; k++) {  
                System.out.print(" ");  
            }  
            for (int j = 1;j <= 2*i-1; j++) {  
                if(j==1||j==2*i-1||i==n)  
                    System.out.print("*");  
                else                    
		            System.out.print(" ");  
            }  
            System.out.println();  
        }  
    }  
}

2.3.5 while

//While.java  
public class While {  
    public static void main(String[] args) {  
        int n=10;  
        //先减减再使用
        //while先判断再运行
        while ((--n)>=0){  
            System.out.println("i = " + n);  
        }  
        n=10;  
        System.out.println("==================");  
        //先使用再减减  
        while ((n--)>=0){  
            System.out.println("i = " + n);  
        }  
    }  
}

2.3.6 do_while

//Do_while.java  
public class Do_while {  
    public static void main(String[] args) {  
        int n=10;  
        do {  
            System.out.println(n);  
            n--;  
        }while (n>0);  
        System.out.println("==================");  
        n=0;  
        //先执行再判断  
        do {  
            System.out.println(n);  
            n--;  
        }while (n>0);  
    }  
}

2.4 类与对象(OOP)

所有类均是Object的子类
状态+行为+标识=对象

2.4.1 属性

2.4.1.1 类成员变量

//Object_test.java  
public class Object_test {  
    public static void main(String[] args) {  
        Cat cat = new Cat();  
        cat.name="小花";  
        cat.age=3;  
        cat.color="白色";  
        cat.Info();  
    }  
}  
class Cat{  
    //类属性属性 
    String name;  
    int age;  
    String color;  
    //类方法  
    public void Info(){  
        System.out.println("name:"+this.name+" age:"+this.age+" color:"+this.color);  
    }  
}

2.4.1.2 构造器

初始化对象，在创建对象时自动调用
构造方法的方法名称与其类名需相同
构造方法可以重载

//Object_test.java  
public class Object_test {  
    public static void main(String[] args) {  
        Cat cat = new Cat("小花",2,"黄色");  
        cat.Info();  
    }  
}  
class Cat{  
    //类属性  
    String name;  
    int age;  
    String color;  
    //无参构造器(默认)，方法重载时，默认的将消失，如需要，自己申明  
    public Cat(){
	    //this(参数列表)，即在自身中调用构造方法
	    //1.只能在构造器中使用
	    //2.如果要使用，代码必须放在构造器的第一条语句
	    this("小白",3,"黑色");
	}
    //有参构造器  
    public Cat(String name,int age,String color){
	    //this就是指对象本身，谁调用就是谁,只能在类内部使用
	    
	    //this可以用于区分属性和局部变量
        this.name=name;  
        this.age=age;  
        this.color=color;
        //this可以访问本类的属性、方法、构造器
        this.Info();
    } 
    //类方法  
    public void Info(){  
        System.out.println("name:"+this.name+" age:"+this.age+" color:"+this.color);  
    }  
}

//反汇编字节码文件
//-c 反汇编
//-v 输出附加信息
//-p 显示所有类和成员
//javap -c -v 文件名.class(可以除去后缀)

2.4.1.3 访问修饰符

成员变量和成员方法均可被修饰

2.4.2 重载

1.方法名必须相同
2.参数类型不同或者个数不同

2.4.2.1 方法重载

//overloaded.java  
public class overloaded {  
    public static void main(String[] args) {  
        overload overload = new overload();  
        System.out.println(overload.calc(1,2));  
        System.out.println(overload.calc(1,2,3));  
        System.out.println(overload.calc(1.0,2.0));  
        System.out.println(overload.calc(1.0,2.0,3.0));  
    }  
}  
class overload{  
    //方法重载  
    /*  
    * 1.方法名必须相同  
    * 2.参数类型不同或者个数不同  
    * */    
    public int calc(int a,int b)  
    {  
        return a+b;  
    }  
    public int calc(int a,int b,int c)  
    {  
        return a+b+c;  
    }  
    public double calc(double a,double b)  
    {  
        return a+b;  
    }  
    public double calc(double a,double b,double c)  
    {  
        return a+b+c;  
    }  
}

2.4.2.2 可变参数

接收可变参数个数的方法
1.参数可以是任意个>=0
2.本质其实就是数组
3.形参列表中，可变参数必须在最后
4.一个方法中，只能有一个可变参数

//Variadics.java  
public class Variadics {  
    public static void main(String[] args) {  
        Method method = new Method();  
    System.out.println(method.sum(1,2,3,4,5,6,7,8,9,10));
    System.out.println(method.sum(1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9,10.0));  
    }  
}  
class Method{  
    //可变参数接收  
    public int sum(int... args){  
        int sum_all=0;  
        for(int i=0;i<args.length;i++){  
            sum_all+=args[i];  
        }  
        return sum_all;  
    }  
    //方法重载  
    public double sum(double... args){  
        double sum_all=0;  
        for(int i=0;i<args.length;i++){  
            sum_all+=args[i];  
        }  
        return sum_all;  
    }  
}

2.4.3 String类

2.4.3.1 String类的介绍

String 类是final的，意味着它不能被子类继承
String 类实现了 Serializable 接口，意味着它可以序列化
String 类实现了 Comparable 接口，意味着最好不要用==来比较两个字符串是否相等，而应该用 equals() 方法

2.4.3.2 hashCode 方法

每一个字符串都会有一个 hash 值

//String类的hashcode方法实现
public int hashCode() {
	//首先检查是否已经计算过哈希码
    if (h == 0 && !hashIsZero) {  
        h = isLatin1() ? StringLatin1.hashCode(value)  
                       : StringUTF16.hashCode(value);  
        if (h == 0) {  
            hashIsZero = true;  
        } else {  
            hash = h;  
        }  
    }  
    return h;  
}

2.4.3.3 substring 方法

用来截取字符串

//String_01.java  
public class String_01 {  
    public static void main(String[] args) {  
        String str = "Hello, world!";  
        String subStr = str.substring(7, 12);  
        // 从第7个字符（包括）提取到第12个字符（不包括）  
        System.out.println(subStr);  // 输出 "world"
        System.out.println(str.hashCode());  
    }  
}

2.4.3.4 indexOf 方法

indexOf 方法用于查找一个子字符串在原字符串中第一次出现的位置

//String_01.java  
public class String_01 {  
    public static void main(String[] args) {  
        String str="hello world";  
        System.out.println(str.indexOf("world"));  
    }  
}

2.4.3.5 引用数据类型的拷贝

//Person.java  
public class Person {  
    public static void main(String[] args) {  
        Person_1 person = new Person_1();  
        person.name = "张三";  
        person.age = 18;  
        My_Tools my_tools = new My_Tools();
        //传过去的是引用  
        Person_1 person1=my_tools.Copy_Object(person);  
        System.out.println("对象1的hash值="+person.hashCode());  
        System.out.println("对象2的hash值="+person1.hashCode());  
        if (person.hashCode()==person1.hashCode())  
            System.out.println("相同");  
        else            
	        System.out.println("不同");  
    }  
}  
  
class Person_1{  
    String name;  
    int age;  
}  

class My_Tools{  
    //拷贝对象  
    public Person_1 Copy_Object(Person_1 ob j)  
    {  
        Person_1 person_1 = new Person_1();  
        person_1.name = obj.name;  
        person_1.age=obj.age;  
        return person_1;  
    }  
}

2.4.4 包

在 Java 中，使用package来解决名字冲突
Java中的包：如何创建、导入和使用 package 来优化代码结构

例如：
小明的Person类存放在包ming下面,因此,完整类名是ming.Person；
小红的Person类存放在包hong下面,因此,完整类名是hong.Person；
小军的Arrays类存放在包mr.jun下面,因此,完整类名是mr.jun.Arrays；
JDK 的Arrays类存放在包java.util下面,因此,完整类名是java.util.Arrays。
在定义class的时候,我们需要在第一行声明这个class属于哪个包。

Java中常用的包

java.lang.* //默认使用的包（默认引入，不需要手动引入）
java.util.* //常用工具需要的包
java.net.* //网络编程需要的包
java.awt.* //界面开发需要的包
import xxxx（包名），可以使用通配(*)导入，也可以具体类导入

2.4.5 封装

将方法封装到类内部,根据需要进行过滤验证，保证安全性
数据被保护在类的内部，尽可能地隐藏内部的实现细节，只保留一些对外接口使之与外部发生联系。

2.4.5.1 无参构造器封装

//encapsulation.java  
public class encapsulation {  
    public static void main(String[] args)  
    {  
        Person_11 person_11 = new Person_11();  
        person_11.setName("张三");  
        person_11.setAge(18);  
        person_11.setSalary(10000);  
        person_11.Info();  
    }  
}  
class Person_11 {  
    private String name;  
    private int age;  
    private double salary;  
  
    public String getName() {  
        return name;  
    }  
  
    public void setName(String name) {  
        if (name.length()>=0&&name.length()<=20)  
            this.name = name;  
        else            
	        System.out.println("名字长度不符合要求");  
    }  
  
    public int getAge() {  
        return age;  
    }  
  
    public void setAge(int age) {  
        if (age>=0&&age<=150)  
            this.age = age;  
        else            
	        System.out.println("年龄不符合要求");  
    }  
  
    public double getSalary() {  
        return salary;  
    }  
  
    public void setSalary(double salary) {  
        this.salary = salary;  
    }  
    public void Info(){  
        System.out.println("姓名："+this.name+" 年龄："+this.age+" 薪水："+this.salary);  
    }  
}

2.4.5.2 有参构造器

//encapsulation.java  
public class encapsulation {  
    public static void main(String[] args)  
    {  
        Person_11 person_11 = new Person_11();  
        person_11.setName("张三");  
        person_11.setAge(18);  
        person_11.setSalary(10000);  
        person_11.Info();  
        System.out.println("==========================");  
        Person_11 person_12 = new Person_11("李四",19,20000);  
        person_12.Info();  
    }  
}  
class Person_11 {  
    private String name;  
    private int age;  
    private double salary;  
  
  
    public Person_11()  
    {}  
    public Person_11(String name,int age,double salary){  
        this.setName(name);  
        this.setAge(age);  
        this.setSalary(salary);  
    }  
  
    public String getName() {  
        return name;  
    }  
  
    public void setName(String name) {  
        if (name.length()>=0&&name.length()<=20)  
            this.name = name;  
        else            
	        System.out.println("名字长度不符合要求");  
    }  
  
    public int getAge() {  
        return age;  
    }  
  
    public void setAge(int age) {  
        if (age>=0&&age<=150)  
            this.age = age;  
        else            
	        System.out.println("年龄不符合要求");  
    }  
  
    public double getSalary() {  
        return salary;  
    }  
  
    public void setSalary(double salary) {  
        this.salary = salary;  
    }  
    public void Info(){  
        System.out.println("姓名："+this.name+" 年龄："+this.age+" 薪水："+this.salary);  
    }  
}

2.4.6 继承

解决多类情况下的代码复用问题
在 Java 语言中继承就是子类继承父类的属性和方法，使得子类对象(实例)具有父类的属性和方法，或子类从父类继承方法，使得子类具有父类相同的方法

上图继承关系可以递归下去
Java中继承机制是单继承，即子类只能继承一个父类
私有的属性和方法不能在子类直接访问，但是可以间接操作
什么时候适合使用继承？

什么是什么的关系才能用

2.4.6.1 简单的继承

//inherit.java  
public class inherit {  
    public static void main(String[] args) {  
        Student student = new Student();  
        student.name="张三";  
        student.age=18;  
        student.school="北京大学";  
        student.study();  
    }  
}  
//父类  
class Person_111{  
    public String name;  
    public int age;  
}  
//子类  
class Student extends Person_111{  
    public String school;  
    public void study(){  
        System.out.println(name+"在"+school+"学习");  
    }  
}

2.4.6.2 继承细节

2.4.6.2.1 私有属性、方法相关

父类写get方法，来获取父类的私有属性内容
父类写call方法，来间接调用父类的私有方法

//inherit.java  
public class inherit {  
    public static void main(String[] args) {  
        Student student = new Student("清华大学");  
        student.age=18;  
        student.setName("李四");  
        student.study();  
        //调用父类的接口方法  
        student.CallPrint();  
    }  
}  
//父类  
class Person_111{  
    private String name;  
    public int age;  
  
    public void setName(String name) {  
        this.name = name;  
    }  
    public String getName() {  
        return name;  
    }  
    private void Print(){  
        System.out.println("姓名："+name+"\t年龄："+age);  
    }  
    public void CallPrint(){  
        Print();  
    }  
}  
//子类  
class Student extends Person_111{  
    public String school;  
  
    public Student(){}  
    public Student(String school){  
        this.school=school;  
    }  
    public void study(){  
        System.out.println(super.getName()+"在"+school+"学习");  
    }  
}

2.4.6.2.2 初始化相关

子类在初始化时(即：创建对象时(调用构造方法时))，默认调用父类的无参构造器，即默认在子类的构造方法中阴藏写着super();

如果父类没有无参构造器，则必须在子类的构造方法中用super(实参)指定使用父类的哪个构造器，否则报错

super在使用时，必须放在构造器的第一行，且调用一直追溯到Object类
(俗称：先有爸爸后有儿)
super()与this()不可共存

//inherit.java  
public class inherit {  
    public static void main(String[] args) {   
        Student student = new Student(); 
        /*输出
        父类Person_111()无参构造器被调用。。。
        子类Student()无参构造器被调用。。。
        */
    }  
}  
//父类  
class Person_111{  
    private String name;  
    public int age;  
  
    public Person_111() {  
        System.out.println("父类Person_111()无参构造器被调用。。。");  
    }  
  
    public Person_111(String name, int age) {  
        this.name = name;  
        this.age = age;  
    }  
}  
//子类  
class Student extends Person_111{  
    public String school;  
  
    public Student(){  
        System.out.println("子类Student()无参构造器被调用。。。");  
    }  
    public Student(String school){  
        this.school=school;  
    }   
}

2.4.6.2.3 查找关系相关

场景：子类继承了父类，但是子类的属性和父类的相同，那调用使用的是哪一个呢？

首先查看子类是否有该属性或者方法
如果有且可以访问，则返回
如果没有则继续向上查找，以此类推
如果查找到一个则返回并终止查询，如果查找过程中出错也终止
如果直接使用成员或者this.成员(二者等价)，依旧同上规则查找。

如果是super.成员，则直接跳过子类去父类查找

//Call_Relationship.java  
public class Call_Relationship {  
    public static void main(String[] args) {  
        Son son = new Son();  
        System.out.println(son.name);  
        System.out.println(son.age);  
    }  
}  
class GrandFather {  
    String name="爷爷";  
    String habby="喝酒";  
}  
class Father extends GrandFather {  
    String name="爸爸";  
    int age=50;  
}  
class Son extends Father {  
    String name="儿子";  
}

2.4.6.2.4 this和super的比较

2.4.6.3 方法重写

子类有一个方法和父类的某个方法的名称、返回类型、参数一样，即子类的方法覆盖了父类的方法，称为子类重写了父类的方法
1.子类返回类型和父类返回类型一样
2.子类返回类型是父类返回类型的子类
3.子类不能缩小父类成员的访问权限
public > protected > default > private

//override.java  
public class override {  
    public static void main(String[] args) {  
        B b = new B();  
        //简单关系重写  
        b.eat();  
        //复杂关系重写  
        //String类是Object的子类  
        System.out.println(b.m1());  
        //权限缩小  
        //public > protected > default > private  
        b.m2();  
    }  
}  
  
class A{  
    public String name;  
    public int age;  
  
    public A() {}  
  
    public A(String name, int age){  
        this.name = name;  
        this.age = age;  
    }  
    public void eat(){  
        System.out.println("A eat");  
    }  
    public Object m1(){  
        return null;  
    }  
    void m2(){  
        System.out.println("A m2");  
    }  
}  
class B extends A{  
    public String color;  
    public B() {}  
    public B(String color, String name, int age){  
        super(name,age);  
        this.color = color;  
    }  
    //重写父类的eat方法  
    public void eat(){  
        System.out.println("B eat");  
    }  
    public String m1(){  
        return null;  
    }  
    protected void m2(){  
        System.out.println("B m2");  
    }  
}

2.4.6.3.1 重载和重写的比较

2.4.7 多态

解决多类情况下的代码复用问题和降低维护成本

方法的多态，类似重载和重写去理解
类的多态，重点！！难点！！！

多态的前提：子类继承父类、父类引用指向子类的对象、子类重写父类的方法
一个对象的编译类型和运行类型可以不一致，也可一样
Animal animal = new Dog();和animal =new Cat();
当编译时，animal 的编译类型就是Animal，而指向的是Dog子类对象
当运行时，animal 可以重新改变指向到Cat子类对象
多态的向上转型
Object obj = new Dog();就是例子，Dog是Object的子类，创建对象时，obj指向了子类Dog，即可以理解为Dog类向上转型(类型)，但运行时是在Dog类

注意事项

可以调用父类的所有成员(但是需考虑访问权限)

不可以调用子类的方法（如需访问，需要向下转型，见向下转型）

//Polymorphism.java  
public class Polymorphism {  
    public static void main(String[] args) {  
        //编译类型是Animal，运行类型是Dogss  
        Animal animal = new Dogss("旺财");//这里是向上转型  
        Food food = new Bone("骨头");  
        Persons person = new Persons("张三");//这里是编译型和运行型一样  
        person.feed(animal,food);  
        System.out.println("====================");  
        //编译类型是Animal，运行类型是Catss  
        Animal animal1=new Catss("汤姆");  
        Food food1=new Fish("三文鱼");  
        person.feed(animal1,food1);  
        System.out.println("====================");  
//        animal.sleep(); 
		//报错(编译报错)，不能调用子类的方法，因不是重写的方法  
        System.out.println("====================");  
        //子类重写父类方法就可以调用，但是子类自己写的方法不能调用  
        animal.eat();//运行调用，即运行态  
        //子类重写的方法，运行时就调用重写的，未重写的就调用父类的  
    }  
}  
//食物类  
class Food{  
    private String name;  
  
    public Food(String name) {  
        this.name = name;  
    }  
  
    public String getName() {  
        return name;  
    }  
  
    public void setName(String name) {  
        this.name = name;  
    }  
}  
class Fish extends Food{  
    public Fish(String name) {  
        super(name);  
    }  
}  
class Bone extends Food{  
    public Bone(String name) {  
        super(name);  
    }  
}  
//动物类  
class Animal{  
    private String name;  
  
    public Animal(String name) {  
        this.name = name;  
    }  
  
    public String getName() {  
        return name;  
    }  
  
    public void setName(String name) {  
        this.name = name;  
    }  
    public void eat(){  
        System.out.println(getName()+"父类正在吃饭");  
    }  
  
}  
class Dogss extends Animal{  
    public Dogss(String name) {  
        super(name);  
    }  
    public void sleep(){  
        System.out.println(getName()+"正在睡觉");  
    }  
    public void eat(){  
        System.out.println(getName()+"子类正在吃饭");  
    }  
}  
class Catss extends Animal{  
    public Catss(String name) {  
        super(name);  
    }  
}  
  
//主人  
class Persons{  
    private String name;  
  
    public Persons(String name) {  
        this.name = name;  
    }  
  
    public String getName() {  
        return name;  
    }  
  
    public void setName(String name) {  
        this.name = name;  
    }  
    //如果不使用多态，形参列表一直在变，即多一个动物就要重载一次，代码冗余度高  
    public void feed(Animal animal,Food food){  
    System.out.println(this.name+"喂"+animal.getName()+"吃"+food.getName());  
    }  
}

2.4.7.1 向下转型

子类类型引用名=(子类类型)父类引用;

要求原父类的引用必须指向的是当前目标类型的对象
只能强转父类的引用，不能强转父类的对象(对象在堆中,引用在栈中)

向下转型后可以访问子类的成员了(上面的例子无法访问)

//上述基础上转类型，即可调用子类的特有方法
//条件1
Animal animal = new Dogss("旺财");//这里是向上转型
Dogss dogss = (Dogss) animal;  //这里是向下转型
((Dogss) animal).sleep();
System.out.println("====================");
//Catss catss = (Catss) animal;//报错,意思就说想把狗变成猫

//条件2
Animal animal2 = new Animal("山猪");
Dogss dogss1 = (Dogss) animal2; //报错，原理其实是上面的狗变猫

2.4.7.2 instanceof

判断对象的运行类型是XX或者XX的子类

//Use_Instanceof.java
public class Use_Instanceof {  
    public static void main(String[] args) {  
        DD dd = new DD();  
        //instanceof用于判断对象的运行类型是否是某类或者某类的子类
        System.out.println(dd instanceof DD);//true  
        System.out.println(dd instanceof CC);//true  
  
        CC cc = new DD();  
        System.out.println(cc instanceof DD);//true  
        System.out.println(cc instanceof CC);//true  
  
        Object obj=new Object();  
        System.out.println(obj instanceof DD);//false  
        System.out.println(obj instanceof CC);//false  
    }  
}  
class CC{}  
class DD extends CC{}

2.4.7.3 动态绑定机制

当调用对象的方法时，该方法会和对象的运行类型绑定
当调用对象的属性时，没有动态绑定机制，那里调用那里使用

如果没有，则发挥继承机制查找

//Dynamic_binding.java  
public class Dynamic_binding {  
    public static void main(String[] args) {  
        //编译类型AAA，运行类型BBB  
        AAA a = new BBB();  
        //调用链:子类找sum有，直接使用子类sum  
        System.out.println(a.sum());    //40  
        //调用链:子类找sum1有，直接使用子类sum1  
        System.out.println(a.sum1());;  //30  
        //注销掉子类的sum方法的调用链:  
        // 子类找sum没,去父类找到使用父类sum,但是父类中有个getI方法，但是子类父类都有,用哪个呢？这时就看运行类型是谁就用谁的，如果子类没有sum方法，就找父类，父类也没有，就报错  
        System.out.println(a.sum());//30  
        //注销掉子类的sum1方法的调用链:  
        //子类找sum1没,去父类找到使用父类sum1,但是父类中有个变量i，这个用谁的呢？答案：用父类的(调用对象的属性时，没有动态绑定机制)
        System.out.println(a.sum1());//20  
        //结论：  
        // 1.当调用对象的方法时，该方法会和对象的运行类型绑定  
        // 2.当调用对象的属性时，没有动态绑定机制，那里就调用那里使用  
        // 3.如果没有，则发挥继承机制查找  
    }  
}  
  
class AAA{  
    public int i=10;  
    public int sum(){  
        return getI()+10;  
    }  
    public int getI(){  
        return i;  
    }  
    public int sum1(){  
        return i+10;  
    }  
}  
class BBB extends AAA{  
    public int i=20;  
    public int sum(){  
        return i+20;  
    }  
    public int getI(){  
        return i;  
    }  
    public int sum1(){  
        return i+10;  
    }  
}

2.4.8 Object类

所有类的根类，所有类默认继承自Object类

2.4.8.1 `==`和equal

==是比较运算符
1.可以比较基本类型，也可以比较引用类型
2.如果比较基本类型，则比较值是否相等
3.如果比较引用数据类型，则比较的是指针的指向是否相等

//Object_test01  
public class Object_test01 {  
    public static void main(String[] args) {  
        //此处的等于是基本数据类型的比较  
        int num1=100;  
        int num2=100;  
        int num3=200;  
        System.out.println(num1==num2);//true  
        System.out.println(num1==num3);//false  
        //此处的等于是引用类型的比较,即指针的比较  
        XX x0 = new XX();  
        XX x1 = x0;  
        XX x2 = new XX();  
        System.out.println(x1==x0);//true  
        System.out.println(x1==x2);//false  
  
        YY yy = new YY();  
        XX x3 = yy;  
        System.out.println(yy==x3);//true  
    }  
}  
class XX{}  
class YY extends XX{}

equal：Object默认是比较两个对象是否一样，只能判断引用类型
其他很多类都重写了该方法，比较的内容与具体实现有关

//Object_test01  
public class Object_test01 {  
    public static void main(String[] args) {  
        String str1 = new String("String");  
		String str2 = new String("String");  
		//可以看equal原码进行查看  
		System.out.println(str1==str2);//false  
		System.out.println(str1.equals(str2));//true  
    }  
}

2.4.8.2 hashcode

如果两个引用指向同一对象，则哈希值一样
如果两个引用指向不是统一对象，则哈希值不一样

类似指针理解，内存地址

//Object_test02.java  
public class Object_test02 {  
    public static void main(String[] args) {  
        X x = new X();  
        X x1 = new X();  
        X x2=x;  
        System.out.println("x的hash值="+x.hashCode());  
        System.out.println("x1的hash值="+x1.hashCode());  
        System.out.println("x2的hash值="+x2.hashCode());  
        Y y = new Y();  
        System.out.println("y的hash值="+y.hashCode());  
  
    }  
}  
class X{}  
class Y{}

2.4.8.3 toStirng

Object类的实现

//返回完整类名和16进制哈希值
public String toString() {  
    return getClass().getName() + "@" + Integer.toHexString(hashCode());  
}

重写实现

//Object_test03.java  
public class Object_test03 {  
    public static void main(String[] args) {  
        Person_s person_s = new Person_s("张三", 18);  
        //以下方式等价  
        System.out.println(person_s);  
        System.out.println(person_s.toString());  
    }  
}  
class Person_s {  
    private String name;  
    private int age;  
  
    public Person_s(String name, int age) {  
        this.name = name;  
        this.age = age;  
    }  
  
    public String getName() {  
        return name;  
    }  
  
    public void setName(String name) {  
        this.name = name;  
    }  
  
    public int getAge() {  
        return age;  
    }  
  
    public void setAge(int age) {  
        this.age = age;  
    }  
  
    @Override  
    public String toString() {  
        return "Person_s{" +  
                "name='" + name + '\'' +  
                ", age=" + age +  
                '}';  
    }  
}

2.4.8.4 finalize(java9开始不鼓励使用)

垃圾回收器，类似C++析构函数
Object的finalize方法有接口没实现，需要可重写

//Object_test04.java  
public class Object_test04 {  
    public static void main(String[] args) {  
        Car car = new Car("宝马");  
        car = null;
        //主动触发垃圾回收器,且不阻塞在此处(从输出结果可看出)    
        System.gc();
        System.out.println("end");  
    }  
}  
class Car{  
    private String name;  
  
    public Car(String name) {  
        this.name = name;  
    }  
  
    @Override  
    protected void finalize() {  
        System.out.println("被当成垃圾回收啦。。。。");  
    }  
}

2.5 递归

自身调用自己，从堆栈内存分析，好理解

2.5.1 汉诺塔

/*  
汉诺塔问题  
 */public class Hannuo {  
    public static void main(String[] args) {  
        int n=10;  
        save abc=new save();  
        abc.sava_hannuo(n,'a','b','c');  
    }  
}  
  
class save{  
    public void sava_hannuo(int n,char a,char b,char c){  
        if (n==1)  
            System.out.println(a+"->"+c);  
        else {  
            sava_hannuo(n-1,a,c,b);  
            System.out.println(a+"->"+c);  
            sava_hannuo(n-1,b,a,c);  
        }  
    }  
}

2.5.2 斐波那契

//Fibonacci.java  
public class Fibonacci {  
    public static void main(String[] args) {  
        Save save = new Save();  
        System.out.println(save.Fibonacci(10));  
    }  
}  
class Save {  
    public int Fibonacci(int n)  
    {  
        if(n==1||n==2)  
            return 1;  
        else            
	        return Fibonacci(n-1)+Fibonacci(n-2);  
    }  
}

2.6 类变量

2.6.1 静态变量

静态变量使用static修饰，类加载的时候生成
特点：被同一个类的所有对象共享
访问控制权限依旧生效
可以通过对象名调用，也可以通过类名调用

//OOP_styatic_var.java  
public class OOP_styatic_var {  
    public static void main(String[] args) {  
        Game person1 = new Game("小王");  
        Game person2 = new Game("小李");  
        Game person3 = new Game("小赵");  
        person1.Games();  
        person1.count++;  
        person2.Games();  
        person2.count++;  
        person3.Games();  
        person3.count++;  
        System.out.println("一共有"+Game.count+"人在玩游戏");  
    }  
}  
class Game{  
    private String name;  
    public static int count=0;  
    public Game(String name){  
        this.name = name;  
    }  
    public void Games(){  
        System.out.println(this.name+"加入游戏");  
    }  
}

2.6.2 静态方法

可以不创建对象就使用类的方法（类似的有Math类的一些方法）
提高开发效率
可以通过对象名调用，也可以通过类名调用
静态方法内不能使用this和super

静态方法只能访问静态成员

//OOP_styatic_methon.java  
public class OOP_styatic_methon {  
    public static void main(String[] args) {  
        System.out.println(Tools.add(100,200));  
        System.out.println(Tools.sub(100,200));  
        System.out.println(Tools.mul(100,200));  
        System.out.println(Tools.div(100,200));  
    }  
}  
class Tools{  
    public static int add(int a,int b)  
    {  
        return a+b;  
    }  
    public static int sub(int a,int b)  
    {  
        return a-b;  
    }  
    public static int mul(int a,int b)  
    {  
        return a*b;  
    }  
    public static int div(int a,int b)  
    {  
        return a/b;  
    }  
}

2.6.3 代码块(类创建调用)

解决代码复用情况(多个构造器均引用的代码)
代码块调用的顺序优先于构造器

创建对象时调用

//CodeBlock.java  
public class CodeBlock {  
    public static void main(String[] args) {  
  
        Movie movie = new Movie("你好，张三");  
        System.out.println("===============");  
        Movie movie2 = new Movie("人民的名义", 100, "李四");  
    }  
}  
  
class Movie {  
    private String name;  
    private double price;  
    private String director;  
  
    {  
        System.out.println("电影屏幕打开...");  
        System.out.println("广告开始...");  
        System.out.println("电影正是开始...");  
    };  
  
    public Movie(String name) {  
        System.out.println("Movie(String name) 被调用...");  
        this.name = name;  
    }  
  
    public Movie(String name, double price) {  
  
        this.name = name;  
        this.price = price;  
    }  
  
    public Movie(String name, double price, String director) {  
  
        System.out.println("Movie(String name, double price, String director) 被调用...");  
        this.name = name;  
        this.price = price;  
        this.director = director;  
    }  
}

2.6.3.1 静态代码块(类加载调用)细节1

对象创建时调用(先类加载,按照继承关系，再创建对象)
子类创建时父类加载调用
使用类的静态属性或方法调用

且只加载一次

//CodeBlockDetail.java  
public class CodeBlockDetail {  
    private static BBB bbb;  
  
    public static void main(String[] args)  
    {  
        //1.对象创建时调用  
//        AAA aaa = new AAA();  
        System.out.println("========================");  
        //2.子类创建时父类加载调用  
        BBB bbb = new BBB();  
        System.out.println("========================");  
        //3.使用类的静态属性或方法调用
        //4.一次加载类，只会被调用一次
        AAA.staticMethod();  
        System.out.println(AAA.n); 
    }  
}  
class AAA{  
    public static int n=100;  
    static {  
        System.out.println("AAA的静态代码块");  
    }  
    public AAA()  
    {  
        System.out.println("AAA的构造方法");  
    }  
    public static void staticMethod()  
    {  
        System.out.println("AAA的静态方法");  
    }  
}  
class BBB extends AAA{  
    static {  
        System.out.println("BBB的静态代码块");  
    }  
    public BBB()  
    {  
        System.out.println("BBB的构造方法");  
    }  
}

2.6.3.2 静态代码块细节2

调用静态代码块和静态属性初始化变量时，优先级相同，(如果有多个静态代码块)按照顺序执行
调用普通代码块和普通属性初始化变量时，优先级相同，(如果有多个普通代码块)按照顺序执行
静态代码块优先级高于普通代码块

构造器最后执行(构造器中第一行隐藏super()和本类普通代码块)

//CodeBlockDetail2.java  
public class CodeBlockDetail2 {  
    public static void main(String[] args) {  
        A a = new A();  
    }  
}  
class A{  
    //静态代码块  
    public static int n=getN();  
    static{  
        System.out.println("A类静态代码块被初始化");  
    }  
  
    public static int getN(){  
        System.out.println("A类静态变量n被初始化");  
        return 10;  
    }  
    //普通代码块  
    {  
        System.out.println("A类普通代码块被初始化");  
    }  
    public int n2=100;  
    public A(){  
        System.out.println("A类构造方法被初始化");  
    }  
}

2.6.4 类加载和创建对象执行过程

父类加载，执行父类静态代码块和静态属性初始化(同优先级)
子类加载，执行子类静态代码块和静态属性初始化(同优先级)
创建对象

执行子类构造器，进入super()，进入父类构造器，再进入父类的普通代码块和普通属性的初始化，执行结束super()，回到子类的构造器继续执行子类的普通代码块和普通属性的初始化

//CodeBlockDetail3.java  
public class CodeBlockDetail3 {  
    public static void main(String[] args) {  
        //1.类加载         先加载 父类 A02      再加载 B02             //2.创建对象        从子类的构造器开始  
        new B02();//对象  
    }  
}  
  
class A02 { //父类  
    private static int n1 = getVal01();  
    static {  
        System.out.println("A02的一个静态代码块..");//(2)  
    }  
    {  
        System.out.println("A02的第一个普通代码块..");//(5)  
    }  
    public int n3 = getVal02();//普通属性的初始化  
    public static int getVal01() {  
        System.out.println("getVal01");//(1)  
        return 10;  
    }  
  
    public int getVal02() {  
        System.out.println("getVal02");//(6)  
        return 10;  
    }  
  
    public A02() {//构造器  
        //隐藏  
        //super()  
        //普通代码和普通属性的初始化......  
        System.out.println("A02的构造器");//(7)  
    }  
}  
  
class B02 extends A02 { //  
  
    private static int n3 = getVal03();  
  
    static {  
        System.out.println("B02的一个静态代码块..");//(4)  
    }  
    public int n5 = getVal04();  
    {  
        System.out.println("B02的第一个普通代码块..");//(9)  
    }  
  
    public static int getVal03() {  
        System.out.println("getVal03");//(3)  
        return 10;  
    }  
  
    public int getVal04() {  
        System.out.println("getVal04");//(8)  
        return 10;  
    }  
    public B02() {//构造器  
        //隐藏了  
        //super()  
        //普通代码块和普通属性的初始化...  
        System.out.println("B02的构造器");//(10)  
    }  
}

2.7 面向对象关键字

2.7.1 instanceof

1
2
3

//检查是否是该类的子类
String s = new String();  
System.out.println(s instanceof Object);

2.7.2 static

//1.上面讲的静态代码那块
//2.静态导入
import static java.lang.Math.PI;  
System.out.println(PI);

2.7.3 final

被final修饰的类将不能被继续向下继承

2.7.4 abstract

抽象修饰符(修饰类、方法)
抽象类的子类都必须实现父类的抽象方法(除非子类也是抽象的)
抽象类也不能new出来，只能靠子类去实现
抽象方法必须在抽象类中

2.8 javaDoc

/*  
* @Author:作者  
* @title:标题  
* @time:时间  
* @description:描述  
* @version:版本  
* */

方法上
/**  
 * @param args  
 * @throws Exception  
 * @return void  
 */
生成
javadoc -encodeing -UTF-8 charset UTF-8 *.java

2.9 接口

java中类只能单继承，而接口可以多继承
接口不能new出来，只能被子类实现
接口的作用：是一个规范

//定义接口
public interface Tools {  
    public abstract void add();  
    //定义的方法默认是public abstract
    //定义的常量是public static final
    void delete();  
    void update();  
}

//实现接口的类（需要实现接口定义的方法）
public class ToolImpl implements Tools{  
  
    @Override  
    public void add() {}  
  
    @Override  
    public void delete() {}  
  
    @Override  
    public void update() {}  
}

2.10 内部类

public class Test {  
    public static void main(String[] args) {  
        Outobj outobj = new Outobj();  
        Outobj.Inner inner = outobj.new Inner();  
        inner.in();  
        System.out.print(inner.getAge());  
    }  
}  
class Outobj{  
    private int age=10;  
    public void out(){  
        System.out.println("这是一个外部类");  
    }  
    public class Inner{  
        public void in(){  
            System.out.println("这是一个内部类");  
        }  
        // 获取外部类的属性  
        public int getAge(){  
            return age;  
        }  
    }  
}

2.11 IO操作

IO是指 Input/Output，正面理解输入和输出。以内存为中心

2.11.1 文件操作

2.11.1.1 根据路径创建

private static void createFile(String filepath) {  
    // 获取当前项目的根目录  
    String projectRoot = System.getProperty("user.dir");  
    // 构建正确的文件路径  
    String FinallyfilePath = projectRoot +"\\"+filepath;  
    File file = new File(FinallyfilePath);  
    if (!file.exists()) {  
        try {  
            file.createNewFile();  
            System.out.println("文件创建成功");  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }else {  
        System.out.println("文件已存在");  
    }  
}

2.11.1.2 已知父目录

private static void createFile01(String filename) {  
    String projectRoot = System.getProperty("user.dir");  
    // 构建正确的文件路径  
    String parentfilePath = projectRoot +"\\src\\study\\_07\\tmp\\";  
    File file = new File(parentfilePath, filename);  
    if (!file.exists()) {  
        try {  
            file.createNewFile();  
            System.out.println("文件创建成功");  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }else {  
        System.out.println("文件已存在");  
    }  
}

2.11.1.3 获取文件属性

private static void getFileContents(String filename) {  
    String projectRoot = System.getProperty("user.dir");  
    String parentfilePath = projectRoot +"\\src\\study\\_07\\tmp\\";  
    File file = new File(parentfilePath + filename);  
    System.out.println("是否是一个文件夹:"+file.isDirectory());  
    System.out.println("是否是一个文件:"+file.isFile());  
    if (!file.isFile()) {  
        System.out.println("这不是一个文件");  
    } else {  
        System.out.println("文件的名称为:"+file.getName());  
        System.out.println("文件的绝对路径为:"+file.getAbsolutePath());  
        System.out.println("文件的大小为:"+file.length());  
        if (file.canRead()){  
            System.out.println("文件可读");  
        }else {  
            System.out.println("文件不可读");  
        }  
    }  
}

2.11.1.4 删除文件

private static void deleteFile(String filename){  
    String projectRoot = System.getProperty("user.dir");  
    String parentfilePath = projectRoot +"\\src\\study\\_07\\tmp\\";  
    File file = new File(parentfilePath + filename);  
    if (file.exists()){  
        if (file.delete()){  
            System.out.println("文件删除成功");  
        }else {  
            System.out.println("文件删除失败");  
        }  
    }else {  
        System.out.println("文件不存在");  
    }  
}

2.11.2 目录操作

2.11.2.1 创建目录

private static void createDir(String dirname){  
    String projectRoot = System.getProperty("user.dir");  
    String parentfilePath = projectRoot +"\\src\\study\\_07\\tmp\\";  
    File file = new File(parentfilePath + dirname);  
    if (!file.exists()){  
        file.mkdir();  
        System.out.println("文件夹创建成功");  
    }else {  
        System.out.println("文件夹已存在");  
    }  
}

2.11.2.2 删除目录(空删)

//只有空的目录才可以删除，不然会显示删除失败
private static void deleteDir(String dirname){  
    String projectRoot = System.getProperty("user.dir");  
    String parentfilePath = projectRoot +"\\src\\study\\_07\\tmp\\";  
    File file = new File(parentfilePath + dirname);  
    if (file.exists()){  
        if (file.delete()){  
            System.out.println("文件夹删除成功");  
        }else {  
            System.out.println("文件夹删除失败");  
        }  
    }else {  
        System.out.println("文件夹不存在");  
    }  
}

2.11.2.3 删除目录(全删)

private static void deleteDir01(String dirname){  
    String projectRoot = System.getProperty("user.dir");  
    String parentfilePath = projectRoot +"\\src\\study\\_07\\tmp\\";  
    File file = new File(parentfilePath + dirname);  
    if (file.exists()){  
        //删除文件夹下所有文件  
        File[] files = file.listFiles();  
        for (File f : files) {  
            f.delete();  
        }  
        //删除文件夹  
        if (file.delete()){  
            System.out.println("文件夹删除成功");  
        }else {  
            System.out.println("文件夹删除失败");  
        }  
    }else {  
        System.out.println("文件夹不存在");  
    }  
}

2.11.3 内容操作

2.11.3.1 写入内容(FileWriter)

private static void writerContent(String filename,String data) throws IOException {  
    String projectRoot = System.getProperty("user.dir");  
    String parentfilePath = projectRoot +"\\src\\study\\_07\\tmp\\";  
    File file = new File(parentfilePath + filename);  
    if (!file.exists()){  
        createFile01(filename);  
    }  
    FileWriter fw = new FileWriter(file.getAbsoluteFile());  
    BufferedWriter bw = new BufferedWriter(fw);  
    bw.write(data);  
    bw.close();  
}

2.11.3.2 写入内容(FileOutputStream)

private static void writerContent01(String filename,String data) throws IOException {  
    String projectRoot = System.getProperty("user.dir");  
    String parentfilePath = projectRoot +"\\src\\study\\_07\\tmp\\";  
    File file = new File(parentfilePath + filename);  
    if (!file.exists()){  
        createFile01(filename);  
    }  
    FileOutputStream fop = new FileOutputStream(file);  
    byte[] contentInBytes = data.getBytes();  
    fop.write(contentInBytes);  
    fop.flush();  
    fop.close();  
}

2.11.3.3 读取内容(Scanner)

private static String readContent(String filename) throws IOException {  
    String projectRoot = System.getProperty("user.dir");  
    String parentfilePath = projectRoot +"\\src\\study\\_07\\tmp\\";  
    File file = new File(parentfilePath + filename);  
    if (file.exists()){  
        String content = "";  
        Scanner sc = new Scanner(new FileReader(file));  
        while(sc.hasNextLine()){  
            content += sc.nextLine();  
        }  
        return content;  
    }else {  
        System.out.println("文件不存在");  
        return null;  
    }  
}

三、Java进阶

3.1 Maven

3.1.1 什么是Maven

Maven是一个跨平台的项目管理工具。作为Apache组织的一个颇为成功的开源项目，其主要服务于基于Java平台的项目创建，依赖管理和项目信息管理。使用maven对java项目进行构建、依赖管理。

3.1.2 Maven的作用

依赖管理
- 依赖指的就是我们项目中需要使用的第三方Jar包, 一个大一点的工程往往需要几十上百个Jar包,按照我们之前的方式,每使用一种Jar,就需要导入到工程中,还要解决各种Jar冲突的问题.
- Maven可以对Jar包进行统一的管理,包括快速引入Jar包,以及对使用的 Jar包进行统一的版本控制
一键构建项目
- 之前我们创建项目,需要确定项目的目录结构,比如src 存放Java源码, resources存放配置文件,还要配置环境比如JDK的版本等等,如果有多个项目那么就需要每次自己搞一套配置,十分麻烦
- Maven为我们提供了一个标准化的Java项目结构,我们可以通过Maven快速创建一个标准的Java项目.

3.1.3 maven安装

maven-3.6.3下载
比较稳定的版本，当然也可以选择其他的，如果遇到idea报错多半是版本不匹配原因

解压到自己的位置即可
添加环境变量
MAVEN_HOME为自己放置的maven解压的文件夹路径
在path中添加%MAVEN_HOME%\bin即可
验证
mvn -v，出现版本即为成功
修改配置文件
路径\apache-maven-3.6.3\conf\settings.xml
添加如下内容，意思为将下载的依赖放到这个文件夹，可以自行更换位置
1
<localRepository>路径\apache-maven-3.6.3\repository</localRepository>

修改镜像（在<mirrors>中）

<mirror>
		<id>alimaven</id>
		<name>aliyun maven</name><url>http://maven.aliyun.com/nexus/content/groups/public/</url>
		<mirrorOf>central</mirrorOf>
	</mirror>
	<mirror>
		<id>alimaven</id>
		<mirrorOf>central</mirrorOf>
		<name>aliyun maven</name><url>http://maven.aliyun.com/nexus/content/repositories/central/</url>
	</mirror>

IDEA配置maven
文件->设置->构建->构建工具->Maven

3.1.4 maven依赖

Maven Repository

3.1.5 maven命令

mvn -v //查看版本 
mvn archetype:create //创建 Maven 项目 
mvn compile //编译源代码 
mvn test-compile //编译测试代码 
mvn test //运行应用程序中的单元测试 
mvn site //生成项目相关信息的网站 
mvn package //依据项目生成 jar 文件 
mvn install //在本地 Repository 中安装 jar 
mvn -Dmaven.test.skip=true //忽略测试文档编译 
mvn clean //清除目标目录中的生成结果 
mvn clean compile //将.java类编译为.class文件 
mvn clean package //进行打包 
mvn clean test //执行单元测试 
mvn clean deploy //部署到版本仓库 
mvn clean install //使其他项目使用这个jar,会安装到maven本地仓库中 
mvn archetype:generate //创建项目架构 
mvn dependency:list //查看已解析依赖 
mvn dependency:tree com.xx.xxx //看到依赖树 
mvn dependency:analyze //查看依赖的工具 
mvn help:system //从中央仓库下载文件至本地仓库 
mvn help:active-profiles //查看当前激活的profiles 
mvn help:all-profiles //查看所有profiles 
mvn help:effective -pom //查看完整的pom信息

打包命令

1
2
3

mvn clean package -Dmaven.test.skip=true		-- 跳过单测打包
mvn clean install -Dmaven.test.skip=true		-- 跳过单测打包，并把打好的包上传到本地仓库
mvn clean deploy -Dmaven.test.skip=true			-- 跳过单测打包，并把打好的包上传到远程仓库

注：执行maven命令需要当前目录有pom依赖，可以用cd命令切换目录