第一阶段Java SE学习概述

Java SE学习概述

Java SE 学习分为五个阶段
第一部分：基础程序设计；
第二部分：面现象对象编程；
第三部分：Java SE 高级应用；
第四部分：JavaSE 新特性；
第五部分：MySQL/JDBC核心技术。
下图包括但不限于整个阶段内容：

第一部分：基础程序设计；

1. 关键字

Java内部已经定义好的单词，具有特殊固定含义，例： public static
viod main。总共有50个。

2. 标识符

定义：自己命名的部分为标识符。
使用注意：在编写标识符时需严格遵守编写规则，防止出错；需注意编写规范，养成良好习惯。

编写规则：
1）标识符只能用26个英文的大小写、0-9数字、下划线_、美元符号$.
2）不能使用关键字和特数字.
3）不能以数字开头.
4）不能包含空格.
5）严格区分大小写.
编写规范：
1）见名知意
2）类、接口名采用采用“驼峰形式”编写，例XxxYyyZzz,注意首字母大写.
3）变量、方法名采用“驼峰形式”编写，例xxxYyyZzz，注意首字母小写.
4）包名小写，单词之间用“.”分开，例如：xxx.yyy.zzz
5）常量名大写，单词间用“_”分开，例：XXX_YYY_ZZZ.

3. 数据类型

计算机只会处理数据0和1，理论上，足够的0和1组合可以表示任何事物，而不同类型的数据（例如数字、文本、视频）需要不同的组合方式。为便于程序员编程，提出数据类型概念。程序员通过编写不同的数据类型，编译器根据设定好的组合方式编译成计算机可执行的机器代码¹。
数据类型可分为两大类：基础数据类型和引用数据类型。

3.1 基础数据类型可进一步分为八类：

数据类型	字节数	取值范围	注意事项
byte	1	-2^7 ~ 2^7-1
shout	2	-2^15 ~ 2^15-1
int（默认）	4	-2^31 ~ 2^31-1
long	8	-2^63 ~ 2^63-1	a = 21214441L(后面加L)
float	4	3.4E+10的负38次方~3.4E+10的38次方	b = 1.2134F(后面加F)
double（默认）	8	1.7E+10的负308次方~1.7E+10的正308次方	c = 212.123 (D通常省略）
char	2	0~ 2^16-1
boolean	1	false 和 true

3.2 基础数据类型转换：

数据类型的转换，有自动类转换 和强制类转换。
自动类转换：

将取值范围小的类型自动提升为取值范围大的类型 。
自动转换方向：byte -> short /char-> int -> long ->float -> double

强制类转换：

将取值范围大的类型强制转换成取值范围小的类型
转换格式：数据类型 变量名 = （数据类型）被强转数据值；
例如：int a = (int)12.2;
其中：12.2表示double型,(int)表示强制转换为int型.

• 成员变量与局部变量
  成员变量有默认值，局部变量无默认值。
  基础类型的成员变量存储在堆中，引用类型的成员变量在栈中声明，在堆中分配存储空间；基础类型的局部变量存储在栈中，引用类型的成员变量在栈中声明，堆中分配存储空间。

数据类型
类
数组
接口
对象
注释

4. 运算符

4.1运算符分类

按照功能区分：算术运算符、赋值运算符、比较运算符、逻辑运算、条件运算符。

分类	运算符
算数运算符	+、-、*、/、%、++、–
赋值运算符	=、+=、-=、*=、/=、%=
关系运算符	>、>=、<、<=、==、!=
逻辑运算符	&、I、^、!、&&、II
条件运算符	(条件表达式)?结果1:结果2；
位运算符	&、I、~、^、<<、>>、>>>

1）注意i++和++i的区别，
2）注意 +=、-=、 *=、 /= 能直接强制转换数据类型.

4.2运算符优先次序

大致顺序为：算数运算->位运算符->关系运算符->逻辑运算符->三元运算符->赋值运算符.

5. 流程控制

流程控制的三种基本结构：顺序结构、分支结构、循环结构

5.1 顺序结构

顺序结构是程序从上到下逐行地执行的结构。

5.2 分支结构

根据条件选择性执行的结构。主要有两种结构：if else语句 、switch case语句

if (判断条件1) {     //判断条件1 是false 还是true
  	执行语句1;
}
...
}else if (判断条件n) {
 	执行语句n;
} else {
  	执行语句n+1;
}
｝

注：if可嵌套多层，else与临近if相匹配。

switch(表达式){
    case 常量值1:         //当表达式等于常量1时，执行语句块1；
    case 常量值2:
    case 常量值3          //case具有穿透性，即cash后面没有break，继续执行
  //case 常量值1|常量值2: 错误示范。      
        语句块1;
        break;           //跳出整个循环。
    。。。
   default:
        语句块n+1;
        break;
}

注意：
1）swith 表达式的值只能是byte、shout、int、long以及枚举（JDK1.5后加入）、String(JDK1.7后加入).
2）case 后面的值必须是常量值，且不能重复。

5.3 循环结构

循环结构	执行判断顺序	循环条件	循环次数是否确定	备注
while	先判断后执行	boolean型	否	–
do…while	先执行后判断	boolean型	否	do…while;
for	先判断后执行	boolean型	是	（；；）

注意：
1）当循环条件依赖于循环体时，用while 或者 do while较为方便。
2）当循环次数确定时，用for循环较为方便。
3）在循环结构中break结束整个循环，continue结束当下循环并开始下一次循环。

6. 数组

数组是保存多个数据的容器。

6.1 数组的四要素

数组的四要素分别为：数据类型、数组名、数组元素、访问下标。

数据类型：一个数组只能保存一种类型，不能保存多种类型
数组名：使用数组名访问数组
数组元素：使用数组参与运算一定是数组元素参与运算，一个数组元素相同于一个给定数据类型的变量
访问下标：通过数组名[访问下标] 格式访问数组元素，当下标为0-至length-1时为合法下标，其他下标为非法下标

6.2 数组的三种声明方式：

//第一种声明方式：动态声明
int arr01[] = new int[4];   //一维数组
int arr11[][] = new int [3][4] //二维数组 
//第二种声明方式：静态声明1
int arr02[] ={1,2,3,4};      //一维数组
int arr12[][] ={{1,2,3,4},{1,2,3},{1,2}};   // 二维数组 
//第三种声明方式，静态声明2
int arr03[] = new int[]{1,2,3,4}; //一维数组
int arr13[][] = new int[][]{{1,2,3,4}{1,2,3}{1,2}}; //二维数组

6.3 数组的常见的算法：

遍历：
略
冒泡：
略

6.4 数组的常见异常：

1）数组越界异常
异常提示：Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException

异常原因：
引用数组元素时，使用了非法访问下标。例如：

int arr[] = new int[]{1,2,3}；
int a = arr[3];   //arr的合法下标为0-2.

2）数组空指针异常
异常提示：
Exception in thread “main” java.lang.NullPointerException

异常原因：
引用数组元素时，被引用数组在堆中，未分配具体存储的空间。例如：

int[][] arr = new int[3][];
System.out.println(arr[0][0]);//NullPointerException

第二部分：面现象对象编程；

1. 基本概念

1.1面向过程的思想与面向对象的思想：

	面向对象 （Process-Oriented Programming）	面向过程（Object Oriented Programming）
思想	考虑处理问题的步骤，按照步骤编写代码	考虑的是哪个类的哪个方法可以处理问题，创建类，建立方法，调用方法。
最小 单位	函数	类/对象
程序员角色	执行者	指挥者

1.1类与对象概念与关系

1）概念与关系
类是抽象的，是规范的模板，提供一类事物的属性与方法，是对象的类型。
对象是具体的，符合类的规范要求，是由类生成的，可以调用类的方法。

1.2类与对象的格式与创建

/*类的创建*/
public class ClassName {
  //成员变量（属性）
  //成员方法 
}
/*对象的创建*/
new 类名()//也称为匿名对象

//给创建的对象命名
//或者说，把创建的对象用一个引用数据类型的变量保存起来
类名 对象名 = new 类名();

1.3类的属性与方法的创建

类属性的创建：
访问修饰符 属性类型 属性名

类的方法的创建：类的五个常规部分为：访问修饰符、返回类型、方法名（参数名）{参数体}。

• 访问修饰符

修饰符	本类	本包	其他包子类	其他包非子类	其他模块
public	√	√	√	√	可建立依赖
protected	√	√	√	×	×
default(无修饰符)	√	√	×	×	×
private	√	×	×	×	×

总结
public … 可以被任何结构访问
protected 本包及非本包的子类可以访问
default … (无修饰符)只有本包的结构可以访问
private…只能在本类结构访问

• 返回类型
  可以是任意一种在java中存在的类型，规定了该方法返回值的类型，规定了返回类型的方法，必须在方法结束前返回一个值，如无返回值 该位置定义为void.
• 方法名
  符合规范(驼峰状，首字母大写)，见名知意。
• 参数组
  参数的类型可以是任何一种出现在java语言中的类型，参数的个数没有数量限制。调用一个带参的方法，必须按照方法要求传参(参数类型要求，参数个数要求，参数顺序要求).
• 方法体
• 代码写在方法体中，大括号内。

1.4static关键字

• static 修饰属性，该属性为所有对象共有属性，被称为类变量，能通过类直接调用，能通过对象直接调用（不推荐）
• static 修饰方法，被称为静态方法，能通过类直接调用，能通过对象直接调用（不推荐）
• static 修饰的静态成员不能访问普通成员，普通成员能访问静态成员。

1.5成员变量与局部变量

成员变量和局部变量的区别
(1)在类中的位置不同
成员变量：类中方法外
局部变量：方法定义中或者方法声明上
(2)在内存中的位置不同
成员变量：在堆中
局部变量：在栈中
(3)生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
(4)初始化值不同
成员变量：有默认值
局部变量：没有默认值，必须定义，赋值，然后才能使用

2. Java 三（四）大特性之一 封装

2.1. 封装的概念

• 封装的目的
  简单讲，解耦合；具体讲，1）隐藏类的实现细节。2）使得外部只能通过事先预设的方法来访问数据，限制成员变量的不合理访问，有利于信息的完整性。3）便于修改，对内部修改时，访问方式不变，外部感觉不出内部被修改，提高程序的嵌入性。
• 如何封装
  使用JavaBean封装，即1）所有属性prative私有化，提供public类型的get/set方法。2）必须有无参构造方法。3）必须有一个能够打印所有属性信息的GetInfo方法。

2.2构造方法和get/set方法

提供访问方式

public class Student{
    
    private String stuName;
    private int stuAge;
    
    public Student(){// 没有任何一个显示构造方法的java类，默认有一个隐示的无参的构造方法
        // 构造方法
    }
    
    public Student(String stuName,int stuAge){// java类中有任何一个显示的有参的构造方法，默认无参的隐示的构造方法就会消失，需要显示的写出来。
        this.stuName = stuName;
        this.stuAge = stuAge;
	}
    
    public String getStuName(){
        return stuName;
    }
    
    public void setStuName(String stuName){
        this.stuName = stuName;
    }
    
    public int getStuAge(){
        return stuAge;
    }
    
    public void setStuAge(int stuAge){
        this.stuAge = stuAge;
    }
    
}

快捷键：Alt +Ins 生成get/set与构造方法

• 构造方法注意事项

1）构造方法与类同名
2）只能在创建对象时用
3）用在实体变量，不用于静态变量，
4）类中默认有一个无参构造方法，若有一个显示有参的构造方法，需要把无参构造方法写出来。

不同的构造方法可以适应不同的业务场合，因为方法名与类名相同，方法重载，以参数数量进行区分。

2.2构造方法重载

• 特点

1）在同一个类中方法名相同，
2）方法名相同，参数名不同（类型、个数、顺序不同）

• 意义

1）方便调用
2）根据业务不同，适用不同场合

2.2变长参数组

• 目的

同种类型的参数可以不传，也可以传任意数量个参数

• 特点

1）再一个方法里，变长参数组只能有一个
2）变长参数组必须再参数列表的最后

• 意义

方便调用点 调用。

• 实例

public class Student{
    
    // 一个方法的参数列表只能定义一个变长参数组
    public void showInfo(String... words){
        // 变长参数组再使用时，和数组一样
        for(int i=0;i < words.length; i++){
            System.out.println(words[i]);
        }
    }
    
    // 变长参数组必须在参数列表的最后一项
    public void showInfo(int a,double d,String... words){
        
    }
}

public class Test{
    public static void main(String[] args){
        Student stu = new Student();
        stu.showInfo("a","b","c","d");// 变长参数组传参，依次传入多个同类型的参数，数量没有限制。
        stu.showInfo();// 可以在定义变长参数的方法调用时，不传递任何参数。
        stu.showInfo(10,5.5,"a","b","c");// 调用带有普通参数和变长参数的方法时先传递普通参数，在传递变长参数组列表。
    }
}

3. Java 三（四）大特性之一 继承

• 概念
  继承可以使得子类具有父类的属性和方法或者重新定义、追加的属性和方法等。一个java类有且只有一个父类（单继承性），若一个java类没有extends关键字，默认继承Object类。

格式：
通过 extends 关键字，例如:[修饰符] class 子类 extends 父类
优点：
1）提高代码复写率
2）提高代码拓展性

• 继承状态下的方法，方法重写
  1）子类编写一个和父类相同的方法，一旦发生方法重写用的是子类的方法。
  2）@override 检测方法重写

• 继承状态下的构造方法
  1）构造方法不能继承
  2）子类的构造方法必须在第一行调用父类的方法，若没显示调用则默认调用父类无参的构造方法，如果有显示的调用可以调用父类的任何一个构造方法。

• this/spuer关键字
  1）含义:
  this代表当前对象，super代表当前对象中从父类引用。
  2）使用范围

①this在实例初始化相关的代码块和构造器中：表示正在创建的那个实例对象，即正在new谁，this就代表谁
②this在非静态实例方法中：表示调用该方法的对象，即谁在调用，this就代表谁。
③ this不能出现在静态代码块和静态方法中使用this

①通过super引用父类的xx，都是在子类中仍然可见的
②不能在静态代码块和静态方法中使用super

3）就近原则

• final

修饰对象	特点
类	类不能被继承
方法	方法不能被重写
属性	属性便常量，通常情况下大写，公开静态常量 声明时被赋值
局部变量	局部变量变成常量，赋值后不能改变
参数	参数在方法内部只能被使用不能被修改

final必须手动赋值，不采用默认值

静态代码块static

1）作用：为静态属性初始化
2）格式：static{ }
3）调用： 被调用顺序： 静态代码块再类加载后即调用，顺序先初始化静态变量 然后调用静态代码块

• 继承中初始化加载顺序
  1）先静态再普通
  2）先父类再子类
  3）先属性再代码块，最后构造方法

3. Java 三（四）大特性之一 多态

父类的引用 传递子类的对象
形成的三个条件：
1有继承 父类定义方法，子类重新写方法
2父类的引用指向子类的对象
3可以使用参数传递时多态，可以直接使用创建对象时多态
格式

编译 运行时类型不一致

向上转型（自动）
父类类型 变量名= new 子类类型；

向下转型（手动）
子类类型 变量名 = （子类类型）父类变量名
instanceof左侧的类的对象时右侧类的对象

4. Java 三（四）大特性之一 抽象

• abstract关键字
  abstract关键字修饰类，修饰方法
  1）修饰类：类不能创建对象
  2）修饰方法：方法变成抽象方法，方法没有方法体
  3）抽象的类中可以有抽象的方法也可以用普通的方法，抽象的方法必须在抽象的类中。

5. Object

• 特点：
  1）Object是所有java类的总父类，任何一个java类都是Object的子类。
  2）Object中的常用方法
  equals方法：比较两个对象是否相等。在Object中equals方法仅能比较两个对象是否来自于同一个内存地址。
  toString方法：将一个对象变成字符串形式返回。当一个对象被放到println方法中准备输出时，会自动调用该对象的toString方法。

6. 接口

7. 包装类

Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而当要使用只针对对象设计的API或新特性（例如泛型），那么基本数据类型的数据就需要用包装类来包装。

1）装箱：把基本数据类型转为包装类对象。
2）拆箱：把包装类对象拆为基本数据类型。
3）自动装箱和自动拆箱：从jdk1.5开始，基础类型和对应引用类型可以自动转换。如果是引用类型需要进行运算，引用类型必须转成基础类型。

• 字符串与包装类的相互转换

参考资料：https://blog.youkuaiyun.com/jhl19981125/article/details/102760461

8. 枚举

概念：枚举用于适应只有固定的几个值的情况，比如一年有四季，一个年有十二个月，一个星期有七天。

• JDK1.5之前的写法
• JDK1.5之后的写法

8. 内部类

概念：在类体中的类
为什么要内部类：
存在形式：
1）成员内部类 可以访问直接访问外部类的私有属性
静态成员内部类 //不能访问外部类普通成员（属性方法）
能访问 外部类的静态成员 不能访问普通成员
静态成员内部类可以定义静态成员和普通成员
在外部类类体外访问内部类需要由外部类类名.内部类类名
静态成员内部类创建对象时，无需先创建外部类对象，直接创建内部类对象
非静态成员内部类
不能声明静态成员，只能声明普通成员

2）局部内部类
概念：声明在方法体中的类
不能声明静态的成员 只能声明普通的成员
局部内部类可以访问问类的所有方法
只能在定义它的方法中 创建对象
匿名内部类
作用 可作为接口的实现类 （实现接口内的方法）

常用内部类：
匿名内部类

8. 注解

• 概念
• Junit架构
• 导jar包：
  需要第三方架构,需要导jar包，jia包里是.class文件，存在工程需要的类
  用marven 管理jia包
  before test after
• 元注解
  元注解为注解的注解，
  自定义注解

8. 异常

异常分类
已检查与未检查异常
try catch
自定义异常
提醒业务异常
getMessage方法

try{
    catch(Exception ex){
}ex.printStackTrace();

第三部分：Java SE 高级应用；

• 相关概念
  并行（parallel）：指两个或多个事件在同一时刻发生
  并发（concurrency）：指两个或多个事件在同一个时间段内发生
  程序：为了完成某个任务和功能，选择一种编程语言编写的一组指令的集合。
  软件：1个或多个应用程序+相关的素材和资源文件等构成一个软件系统。
  进程：运行的程序。
  线程：线程是进程中的一个执行单元，是CPU调度的最小单元。

• 创建和启动线程
  1）继承Thread类

public class Myclass extends Thread{
@override
public void run(){     //重写run方法。
	system.out.println("新线程"); 
	}
}
public class Demo(){
	public static void main(String[] args){
		Myclass myclass = new Myclass(); 
		myclass.start();                //开启新线程
	}
}

2）实现Runnable接口

public void Myclass implements Runnable(){
@override
public void run(){                   //重写run方法
		system.out.println("新线程");
	}
}
public class Demo(){
	public static void main(){
		Myclass myclass =new Myclass();
		Thread thread = new Thread(myclass);
		thread.start;   //开启新线程
	}
}

常用方法：

• public void run() :此线程要执行的任务在此处定义代码。
• public String getName() :获取当前线程名称。
• public static Thread currentThread() :返回对当前正在执行的线程对象的引用。
• public final boolean isAlive()：测试线程是否处于活动状态。如果线程已经启动且尚未终止，则为活动状态。
• public final int getPriority() ：返回线程优先级
• public final void setPriority(int newPriority) ：改变线程的优先级

线程安全

• 锁：同一个对象
  string

集合

collection map
集合变长 优
不固定类型 缺
collection 没有索引 没有获取单个元素的方法
无法使用数组的方法遍历，提出Iterator接口
面向接口编程
Object obj =
输出 经常强转
两个遍历方法
hasNext(); next();
增强FOR
Debug

Collection接口

Collection无独有实现类，靠它的子类工作。
思考它的子类的特点，有无序 是或否去重 增减效率 遍历效率 。
两种遍历方法

• iterator迭代器

 Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            Object o = iterator.next();
            System.out.println(o);
        }

其中，public next():返回迭代的下一个元素。
public boolean hasNext():如果有元素可以迭代，返回 true。

• 增强for循环

for(Object o:list){
	Student student = (student)o;
	System.out.println(student);
}

其中，(student)o为强转，list是实现类对象，o是对象中的元素。

list接口

• 存储元素特点：
  有序、不去重
• 实现类
  ArrayList、LinkedList、Vector
  arraylist 底层使用可变长度的Object数组，当数组元素已满时，数组需要扩容（1.5倍扩容）。由于存储物理地址相邻，遍历效率高，增删效率低。
  特点：
  JDK1.8开始，第一此调用时添加方法，初始化，初始长度为10。

LinkedList 由于双向链表特性，遍历效率低，存取效率低 ，在有存取的需求时 Map效率更高，因此linkedlist 淘汰。

Set接口

• 存储元素特点：
  无序 去重

• 实现类
  1）HashSet 去重原理
  

不妨假设，在HashSet实现类中实现add方法。首先使用先Hashcode方法（HashCode方法需重写）判定两个元素的Hash地址是否相同，若相同，则不执行添加动作。若相同，则使用equals方法（需重写），若相同，则不执行添加动作，若不同，则新元素链接在原元素的next上。若next上有值，继续访问一下，直到next的值为null,并赋值。
其中，元素的数据类型我为：数组加链表的混合模型。

• 重写HashCode方法、equals方法

• 特点：增减效率高、遍历效率低、元素无序

• 2）TreeSet（实际使用频率低）原理
  数据结构 ：二叉树

1确定根节点 2传入数值，当该数值小于根节点时传入左子树，否则传入右子树，接着对比第一个左（右）子树节点，当该数值小于第一个左（右）子树节点时，传入第一个左（右）子树节点的左（右）子树节点，依次类推，当数值与节点相等，则停止操作，当数值与已有节点都不同，新增节点。因此，二叉树数据结构时有序结构。
特点：有序 去重 容易导致二叉树不平衡，即数据多集中于单侧子树。解决方法（红黑树算法），红黑原理：选择合适的根节点，使得树平衡。

• 自然排序

实现Comparable接口，重写compareTo()方法
compareTo()对比实现类元素与传参元素的值，判断大小并排序

//在Student类中重写，implements Comparable.
  @Override
    public int compareTo(Object o) {
        Student stu = (Student)o;
        return this.stuAge - stu.stuAge;
    }

• 定制排序

业务需求不符合自然排序时，或者元素的类型没有实现Comparable接口。

//在main类中重写,
Set set = new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Teacher teacher1 = (Teacher) o1;
                Teacher teacher2 = (Teacher) o2;
                return teacher1.getTeaAge() - teacher2.getTeaAge();
            }
        });

• Collections工具类

Collections类工具	list	set

map接口

键值对

第四部分：JavaSE 新特性；

第五部分：MySQL/JDBC核心技术。**

---

1. https://zhuanlan.zhihu.com/p/137547576 ↩︎