Java体系

JavaSE（J2SE）（Java2 Platform Standard Edition，java平台标准版）
JavaEE（J2EE）(Java 2 Platform,Enterprise Edition，java平台企业版)
JavaME（J2ME）(Java 2 Platform Micro Edition，java平台微型版)。

主要特点：

简单、面向对象、分布式、健壮、安全、体系结构中立、可移植、解释型、高性能、多线程、动态的

基本概念：

JDK（Java Development Kit ）：软件开发工具包，编写 Java 程序的程序员使用
JRE（Java Runtime Environment）：程序运行环境，运行别人写好的 Java 程序
JVM（Java Virtual Machine）：Java 虚拟机，源代码文件.java 编译成 字节码文件.class

Server JRE （Java SE Runtime Environment）：服务端使用的 Java 运行环境
SDK（Software Development Kit）：软件开发工具包，在Java中用于描述1998年~2006年之间的JDK
DAO（Data Access Object）：数据访问接口，数据访问，顾名思义就是与数据库打交道
MVC（Model View Controller）：模型(model)－视图(view)－控制器(controller)的缩写，一种软件设计典范，用于组织代码用一种业务逻辑和数据显示分离的方法

跨平台机制：

JDK(Java Development Kit)：软件开发工具包
javac.exe 编译工具   java.exe 执行工具 JRE（Java Runtime Environment）：程序运行环境 JVM（Java Virtual Machine）：
源代码文件.java 编译成 字节码文件.class

程序计数器：当前线程正在执行的字节码指令的地址
虚拟机栈：存储当前线程运行方法时所需的数据、指令、返回地址

JVM开辟内存：

栈内存
FILO/LIFO：
先进后出，后进先出
（子弹夹模型） 堆内存 方法区（存储区）所有的数据只有一份，且不能更改 常量缓冲区，常量池 方法区（类模块）
字节码文件（类映射空间） 静态元素区 static

默认执行过程：

javac 源文件.java -> 源文件.java 编译成 字节码文件.class
java 字节码文件.class
JVM开辟内存 -> 类加载器（从硬盘将 “字节码文件.class” 搬运到【内存】【方法区】“类映射空间”）
所有执行都在“栈”内存

javap -c 可以查看字节码文件

开发环境配置

  • 安装 JDK
    JDK 下载

    命令行 查看是否已安装 java -version
    java -verbose 查看 JDK 安装路径

  • 环境变量配置

    JAVA_HOME
    C:\Program Files (x86)\Java\jdk1.8.0_91 //JDK 安装路径

    CLASSPATH
    .;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar; //记得前面有个”.”

    Path
    %JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;
    在 Windows10 中，Path 变量里是分条显示的，我们需要将 %JAVA_HOME%\bin;%JAVA_HOME%\jre\bin; 分开添加

汉化

语言包地址

eclipse -> help -> install new software
install -> work with：https://download.eclipse.org/technology/babel/update-site/R0.17.0/2019-06/
点击 add -> 选择 chinese -> next next next

可以汉化，但是存在报错，不知道是不是版本问题，使用版本 2019-09

===========================================

基础语法

Java 注释：

单行注释：//  .....
多行注释：/*  ..... */
文档注释：/** ..... */

数据类型

基本类型：

   整型（4）： byte short int long
浮点型（2）： float double
字符型（1）： char（Unicode编码）
布尔型（1）： boolean

byte（8bit）：范围 -27 ~ 27-1
short（16bit）、int（32bit）、long（64bit）
float（32bit）    ： 0，0*9  ，0*22
double（64bit）： 0，0*19，0*44
char（16bit）、boolean（1bit）

1byte == 8bit（bit：敏感单元位） 0000，0000 （256种组合）

引用类型：

数组 []、类 class、接口 interface、枚举 enum、注解 @interface

常量、变量

标识符常量：final [数据类型] [变量名称] = 值；常量不可更改
变量：[数据类型] [变量名称] = 值；

*变量是一个内存空间，声明必须制定类型；未初始化值，不可以使用；“=” 初始化赋值；变量空间内容有且只有一个；空间内的内容的类型和定义时一致，值可以改变*

常量 在内存（常量缓冲区，常量池）中 初始大小（int 类型） 32bit （double 类型） 64bit
如果初始化的值超出范围，编译会报错：
float a = 3.4F;
long b = 2147483648L;

类型转换：

同种数据类型之间:
    大空间类型 赋值 小空间类型 ->  直接赋值
    byte a = 1; int b = a;
    小空间类型 赋值 大空间类型 -> （小空间类型）强制转换
    int a = 1; byte b = (byte)a; *如果a的值超出b的范围，强制转换编译可以，执行后b的值会发生改变*

    整型和浮点型之间转换，比较精度程度
    byte -> short -> int -> long -（比较的是精确程度）> float -> double

不同数据类型：

    int -> char Unicode码强制转换
    布尔类型不能转换
    包装类（Integer Character Byte Float Double Long...）

运算符

算术运算符、赋值运算符、关系运算符、逻辑运算符、位运算

a = a++ 先备份赋值，后计算
a = ++a 先计算，后备份赋值

语法结构

分支结构：

if switch

循环结构：

for while do...while

for（；；）
for（：） //加强 for 循环，用于遍历，只能取值，不能赋值，没有 index 索引

break、continue 标记

数组

静态初始化：

int[] arr = new int[]｛10，20，30，40｝;
int[] arr = ｛10，20，30，40｝

动态初始化：

int[] arr = new int[8]
有长度，有默认值
整型:0
浮点型：0.0
字符型： '0' -> 48 
布尔型：false
引用数据类型：null

动态参数列表

1
2
3
4
public void funName(int...x){
    //动态参数列表，底层本质 数组
    //动态参数列表只能有一个，且放置在方法参数的末尾
}

类组成

属性、方法、构造方法、程序块

重写类构造方法，默认构造方法需要保留
程序块：
    没有修饰符、没有参数、没有返回值、没有名字的特殊方法
    无法重载，块可以存在多个
    块需要调用才能执行，每次调用构造方法之前，系统会自动调用程序块，执行一次
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
//类封装
public class ArrayBox<E> {
    //属性
    private static final int DEFAULT_CAPACITY=10;
    private Object[] arrDatas;
    private int size = 0;

    //构造方法
    public ArrayBox(){
        arrDatas = new Object[DEFAULT_CAPACITY];
    }
    //构造方法重载
    public ArrayBox(int capacity){
        arrDatas = new Object[capacity];
    }

    //方法
    //1、添加元素
    public boolean add(E ele){
        ensureCapacityInternal(size + 1);
        arrDatas[size++] = ele;
        return true;
    }
    //2、容量校验
    private void ensureCapacityInternal(int minCapacity){
        if(minCapacity - arrDatas.length >0){
            //需要空间超出剩余空间
            grow(minCapacity);
        }
    }
    //3、扩容
    private void grow(int minCapacity){
        //原有空间大小
        int oldCapacity = arrDatas.length;
        //扩容1.5倍
        int newCapacity = oldCapacity + (oldCapacity>>1);
        newCapacity = newCapacity - minCapacity<0 ? minCapacity : newCapacity;
        arrDatas = copy(newCapacity, arrDatas);
    }
    //4、数据转移
    private Object[] copy(int newCapacity, Object[] oldArrDatas){
        Object[] newArrDatas = new Object[newCapacity];
        for(int i=0; i<oldArrDatas.length; i++){
            newArrDatas[i] = oldArrDatas[i];
        }
        return newArrDatas;
    }

    //5、获取元素
    public E get(int index){
        rangeCheck(index);
        return (E)arrDatas[index];
    }
    //6、索引校验
    private void rangeCheck(int index){
        if(index<0 || index>=size){
            //定义异常处理
            throw new BoxIndexOutOfBoundsExection("索引超出范围:index:" + 
			index + ", size:" + size);
        }
    }
    //7、删除元素
    public E remove(int index){
        rangeCheck(index);
        E oldVal = (E)arrDatas[index];
        for(int i = index; i<size-1; i++){
            arrDatas[i] = arrDatas[i+1];
        }
        arrDatas[--size]=null; //末尾元素清空
        return oldVal;
    }
    //8、获取元素个数
    public int size(){
        return size;
    }
}

//自定义异常处理
public class BoxIndexOutOfBoundsExection extends RuntimeException{
    //构造方法
    public BoxIndexOutOfBoundsExection(){}

    public BoxIndexOutOfBoundsExection(String msg){
        super(msg);
    }
}

//main方法使用
ArrayBox<Integer> ab = new ArrayBox<Integer>();
    for(int i=0; i<11; i++){
        ab.add(i*10);
    }

类和类的关系

A is-a B 泛化(继承 实现)
A has-a B 包含(组合 聚合 关联)
A use-a B 依赖(依赖)

继承

  1. 子类 extends 父类
  2. 子类可以调用父类中（public protected）的属性，方法
  3. 子类可以添加自己的属性和方法
  4. 子类可以重写父类方法内容 override
  5. 每一个类都有继承类，默认 Object:引用类型的父类
  6. Java 单继承：目的类使用更安全，可以通过（传递、多实现）实现多继承
  7. 继承在内存中的存在形势*
  8. this和super代替的对象*
– 方法重写override 方法重载overload
类 两个继承关系的类，子类重写父类的方法内容 一个类中的一组方法
权限 子类可以大于等于父类 无要求
特征 final static abstract
父类final 子类不能重写
父类static 子类不存在
父类abstract 子类必须重写		 无要求
返回值 子类可以小于等于父类 无要求
名字 子类父类一致 一个类中的好多方法名必须一致
参数 子类父类一致 每一个方法的参数必须不一致
异常 父类抛出运行时异常，子类可以不予理会；
父类抛出编译时异常，子类抛出的异常个数、类型小于等于父类		 无要求
方法体 方法内容不一致

Object 类中的方法

equals()、hashCode()、toString()、getClass()、notify()、notifyAll()、wait()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//equals()
public boolean equals(Object obj){
	return (this == obj);
}

//hashCode()
public native int hashCode()

//toString()
public String toString(){
	return getClass().getName + "@" + Interger.toHexString(hashCode());
}

//getClass() 获取对象对应的类映射（反射）

protected finalize() 在对象被GC回收的时候，默认调用执行
protected clone()    克隆对象

包含

一个类的对象当做另一个类的属性来存储

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
public class Car {
    public String brand;
    public String type;
    public String color;

    public Wheel wheel; //包含关系

    public Car(){}

    public Car(String brand, String type, String color, Wheel wheel){
        this.brand = brand;
        this.type = type;
        this.color = color;
        this.wheel = wheel;
    }

    public void showCar(){
        System.out.println("这是一辆" + brand + "牌，" + type + "型号, " + color + "的小汽车！");
        System.out.println("车上搭载着" + wheel.brand + "牌" + wheel.size + "尺寸" + 
			wheel.color + "颜色的轮子！");
        wheel.turn();
    }
}

public class Wheel {
    public String brand;
    public int size;
    public String color;

    public Wheel(){};

    public Wheel(String brand, int size, String color){
        this.brand = brand;
        this.size = size;
        this.color = color;
    };

    public void turn(){
        System.out.println("车轮子可以旋转！");
    }
}

//main方法使用
Car car = new Car();
car.brand="奥迪";
car.type="Z4";
car.color="米蓝色";

car.wheel= new Wheel("米其林",400,"酷黑");
car.showCar();

依赖

一个类的方法使用了另一个类的对象（方法中参数传递，方法中自己创建 new）

高内聚低耦合：紧密 继承（实现）> 包含 > 依赖

面向对象三（四）大特性

继承 封装 多态 （抽象）

权限修饰符

public
protected
默认
private

可以修饰类和类成员（除了程序块）
修饰类的时候 只允许 public 默认

final

修饰变量：变量没有赋值，给一次机会；变量有值，不予许再次更改
        变量基本类型，值不可更改；变量引用类型，地址可以修改
修饰属性：和修饰变量类似（修饰属性必须赋初始值，否则编译报错）
修饰方法：方法的最终不可更改，方法不能被子类重写
  修饰类：类不可以被继承（常见的工具类：String Math Scanner等）

static（静态的）
abstract（抽象的）
native（本地的）
transient（短暂的—->序列化）
*synchronized（同步的）
*volatile（不稳定，保护属性、方法的线程安全）

static

可以修饰属性、方法、程序块、类（内部类）
静态元素在类加载时就初始化，此时没有创建对象
静态元素存储在静态元素区，每个类有一个自己的区域
静态元素只加载一次，不属于任何对象，只属于类，可以通过类名访问
静态元素区 GarBage Collection 无法管理，可以认为常驻内存
非静态成员中可以访问静态成员
静态成员中不可以访问非静态成员

类的加载顺序

父类 -> 父类静态空间（属性、方法、程序块）
    执行静态程序块
子类 -> 子类静态空间（属性、方法、程序块）
    执行静态程序块
加载父类非静态成员
    执行程序块，构造方法
加载子类非静态成员
    执行程序块，构造方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
public abstract class Box<E> {

    abstract boolean add(E item);
    abstract E get(int index);
    abstract E remove(int index);
    abstract int size();

    public Box(){
        //构造方法，不能自己使用，只能子类使用
    }

    {
        //程序块
    }

    public void getSize(){
        //普通方法
    }
}

interface IBox{
    public static final String x = "属性必须初始化，默认 public static final";

    /*{
        不能存在程序块
    }*/

    /*public Animal(){
        不能存在构造函数
    }*/

    /*public void showInfo(){
        不能存在具体化方法
    }*/

    public void showA();
    public abstract void showB();
    abstract void showC();
    abstract void showC(int x);
    //不能用 static final 修饰

    default void showDown(){
        //1.8 修饰具体方法
    }
}

interface ——- 直接多继承 ——- interface 接口定义规则
abstract ——- 直接单继承 ——- abstract 抽象类描述事物
class ——- 直接单继承 ——- class 具体描述细节

class ——- 不能直接单继承 ——- abstract 需要将抽象方法具体化
class ——- 不能直接多实现 ——- interface 需要将抽象方法具体化
abstract ——- 直接多实现 ——- interface

多态

(Student\Teacher) extends Person extends Animal —> Object

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

Object o = new Teacher();
o.hashCode();
o.toString();
//只能调用 Object 的方法

Person p = (Person)o;
System.out.println(p.name);  //Person 的属性
p.eat();
p.sleep();
p.talk();
p.work();
//方法调用，Teacher重写的、独有的方法 > Person > Animal

//Student s = (Student)o;
//s.name;
//同级成员不能强制转化，向上、向下转型（造型）运行时 ClassCastException 报错

Teacher t = (Teacher)o;
System.out.println(t.name);  //Teacher 的属性
p.eat();
p.sleep();
p.talk();
p.work();
//方法调用，Teacher重写的、独有的方法 > Person > Animal

枚举

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public enum Week {

    Monday("星期一",1),
    Tuesday("星期二",2),
    Wednesday,
    Thursday,
    Friday,
    Saturday,
    Sunday;

    private Week(){};
    private Week(String name, int index){};
}

GC

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//类中重写
public void finalize(){
    System.out.println("对象被回收了...");
}

//System.gc() 可以看到垃圾回收
Person p = new Person();
System.out.println("Person对象被创建成功！");
p=null;
System.gc();

//Runtime
Runtime r = Runtime.getRuntime();
r.maxMemory();
r.totalMemory();
r.freeMemory();

异常

InputMisMatchException 输入异常
ArrayIndexOutOfBoundsException 数组越界
NegativeArraySizeException 负数
NullPointerException 空指针
NumberFormatException 数字格式
ClassCastException 类型转化
StackOverflowError 栈内存溢出