JavaSE学习摘要

history 显示历史命令
!command 执行上一次的命令
五、第五天
1.JAVA环境的安装与配置
window：
1、jdk 注意路径，不要出现中文，不要出现特殊符
2、进行环境变量的配置

Linux：
如果使用tar包安装（店家推荐）
1、解压tar
2、进行环境变量的配置（重要，必须掌握）
如果需要配置成用户基本的环境变量（不推荐）
vim ~/.bash_profile

第一个程序的编写
public class Test {
// main函数，是java的程序的入口
public static void main(String [] args) {
// 输出一句话，hello
Syste.out.println(“hello java!!!”) ;
}
}

当java代码书写完成，首先需要编译
javac xxxx.java // 编译一个xxx.java文件
六、第六天
1.注释
// 行注释
/*
*/块注释
t空格
n换行
2、变量
概念：
在程序运行过程中，允许值发生改变的量，叫做变量
定义变量：
// 在定义变量的同时赋值
数据类型 变量名称 = 变量值;
// 初始化
int a = 10;
System.out.println(a) ;

3.基本数据类型
四类八种
整形
byte（B） 1字节
short (short int) 2字节
int 4字节
long (long int) 8字节
浮点型（小数）
float 单精度浮点数 4个字节
double 双精度浮点数 8个字节
布尔类型
boolean 值：true（真） false（假）
字符 char 值就是被单引 引起来的单个字符 ‘’

5.类型转换
由低到高的类型会自动转换
char

强制类型转换
从高向低转换
(类型) 变量
public class Test05 {
public static void main(String[] args) {
byte a = 10;
int b = 20;
// int c = a + b ; // success
byte c = (byte) (a + b) ; // error
System.out.println?;
}
}
6.常见运算符：
1、算术运算符
+ – * /(整除) %(求余)
2、关系运算符（比较运算符）
> = (等于) !=(不等于)
3、逻辑运算符
与（并且） 或（或者） 非（取反）
&& || !
4、赋值运算符
= // 表示将右侧的值赋给左侧
+= // a += 10; => a = a + 10
-=
*=
/=
%=
5、自加和自减运算符
int i = 10 ;
i++;
++i;
i–;
–i;

7.从控制台输入变量
// 导入对应的包
import java.util.Scanner;

public class Test12 {
public static void main(String[] args) {
// 得到一个Scanner对象
Scanner sc = new Scanner(System.in) ;
System.out.print(“请输入第一个数：”) ;
// sc.nextInt() 表示从控制台上接受一个整形数据
int a = sc.nextInt();
System.out.print(“请输入第二个数字：”) ;
int b = sc.nextInt();
System.out.println(“a + b = “+ (a + b)) ;
}
}
8.三元(目)运算符

9.程序流程：
顺序（代码都是有左而右、由上而下执行）
分支（选择）
单分支
if (条件) {
// 当条件为真的时候，执行花括 内部的代码

第七天、
1.switch语句
switch（变量）{
case 常亮1：
break；
case 常亮2：
bresk；
…
default：
}
注意：
1、switch语言一般我们需要加上break
2、如果还有其他条件，请加入default
3、switch中的变量的类型：
在jdk1.5之前，只能是char、byte、short、int
在jdk1.5之后，增加了枚举类型
在jdk1.7之后，增加了字符串（String）
目前jdk12，不支持long、浮点型
if选择语句和switch选择语句的比较：
1.switch语句只支持常量值相等的分支判断，而if语句支持更为灵活，任意布尔表达式均可；
2.switch语句通常比一系列嵌套if语句效率更高；逻辑更加清晰
switch语句和if语句的各自使用场景
1.switch建议判断固定值的时候用
2.if建议判断区间或范围的时候用
3.*用switch能做的，用if都能做，单反过来则不行

2.循环结构
for while do…while…
for
for (定义一个变量; 判断是否符 条; 条件升级) {
//循环体
}
while
while(条件) {
// 循环体
}
while
while(条件) {
// 循环体
}
注意：do while 不管条件是否符合，至少会执行一次
一般而言，主要用来做人机交互
break、continue关键字的使用

三种循环都可以用来处理同一问题。一般情况下，它们可以相互代替。下面是这三种循环语句的比较：

while和 do…while循环，只在 while后面指定循环条件，在循环体中应包含使循环趋于结束的语句（如 i++，或者 i=i+1等）。for语句中的第 3个表达式中包含使循环趋于结束的操作，设置可以将循环体中的操作全部放在表达式 3中。因此 for语句的功能更强，凡用 while循环能完成的，用 for循环都能实现。

用 while和 do…while循环时，循环变量初始化的操作应在 while和 do…while语句之前完成。而 for语句可以在表达式 1中实现循环变量的初始化。 while循环、do…while循环和 for循环，都可以用 break语句跳出循环，用 continue语句结束本次循环。 2．三种循环的使用原则

for语句是 C语言中使用最灵活的循环语句，它可以用于循环次数已知的情况，还能用于循环次数不确定的情况，但要给出循环结束条件。 while语句是一种先判断后执行的语句，如果开始不能满足条件，则可以一次都不执行循环体。 do…while语句用法和 while语句相似，也是要求先给出循环条件，经过判断后，根据循环条件是否满足，来确定是否执行循环体。

break：
1、switch 打断switch语句的作用
2、终止循环的作用

continue：
中断本次（一次）循环，进入下次循环

第八天、
1.函数：函数就是一个具有名称的代码块，一个具有特定功能的代码块，所以函数就是一个行为，一个动作，一个过程
2.函数的定义
public static 返回值的类型 函数名称([参数列表]) {
// 函数体
[return 返回结果 ;]
}
注意：java中，函数必须定义在类中
3.函数的调用：
函数名称([参数列表]);
4.函数的参数：
函数可以没有参数，函数也可以有一个参数，也可以有多个参数，
注意：需要申明参数的类型！！！
5.函数的返回值
函数可以没有返回值，请使用void关键字申明
如果函数需要返回值，return 关键字返回结果，并且函数上申明返回值的类型
注意：Java中，函数只能返回在一个值
当函数有返回值的时候，如果需要这个返回值，一定接受它。
6.函数的重载
强数据类型语言中，大多数情况下都存在函数的重载
第九天、
1.数组
一系列数据的组合
2.数组的定义
数据类型 [] 数组名称 = new 数据类型[数组大小];
3.数组元素的访问
数组名称[下标] // 下标从0开始， 最大是数组大小-1
4.数组的大小
数组名称.length属性
5.数组的遍历
一般使用循环完成数组的遍历
使用foreach语句查看数组（只能读不能写）
for（数组类型 temp：数组名）{System…}
6.数组的拷贝
System.Arraycopy(数组1名，数组1起始拷贝索引，数组2名，数组2起始拷贝索引，拷贝匀速的数量)

删除数组中的某个元素，实际上也是数组的拷贝
System.Arraycopy(数组名，要删除的元素索引 + 1，数组名，要删除的元素索引，数组长度 – 要删除的元素索引 + 1)

数组元素的插入，首先进行数组的扩容（先定义一个更大的数组，然后将原数组拷贝进新数组） 和删除类似
7.数组的特点
1、数组只能存储一种数据类型
2、数组长度一旦定义，固定下来了
3、数组申请的内存区域是一段连续内存（重要）
第十天、
1.面向对象
面向对象，本质就是让电脑以人认知世界的方法来编程（构建它的世界）
2.类
是一个抽象单位，不存在，是我们通过特征和行为分门别类得到的给类别，类就是模板、是脑海中的那个模型
3.对象
万物皆对象
4.类的定义：
OO（Oriented Object）：面向对象
OOP（Oriented Object Programming）：面向对象的编程
OOA（）：面向对象分析
OOT（）：面向对象测试
OOD（）：面向对象设计
5.使用类构建对象
对象类型 对象名称 = new 类名称();
Person p1 = new Person();
6.定义类（分门别类的过程）

7.得到对象
类型 对象名称 = new 类型(); // 为属性赋值
对象名称.属性名称 = 属性值;
对象名称.方法名称([参数列表]);
8.变量
局部变量
定义在函数内部的变量，当函数调用完成，也就是函数弹栈之后，局部变量会消失

全局变量
在main函数中定义，在整个程序运行过程中，始终存在，不要回收的变量

成员变量
成员变量定义在类中，属于对象或者类的

成员方法：
定义在类中，所属对象或者类

什么是类/strong>
在生活中我们也有许许多多的例子用来描述类，比如：鸟，狗，猫我们称之为动物类、盘子，刀，案板，筷子我们称之为餐具类，在java中，我们把抽取同类实体的共同性自定义扥一种数据类型称之为类。譬如，我们要定义一个人的类（那么这个人的名字，姓名，性别， 住址、、、我门都可以将它定义在同一个方法中，也就是实体类）
什么是对象/strong>
当面向封装了具体功能类，若要使用这个类，一般情况下，在Java中需要通过创建这个类的实体来使 用。这个实体称之为对象。在开发中，我们是在不断的找封装不同功能的类。基于这些类，创建其对象， 使用这些对象完成相应的操作。
通过上面的讲解和分析得出：面向对象是基于面向过程，对象是将功能进行了封装。只要找到了具体 的类，创建出对象，就可以调用其中的具体功能。面向对象也是用来解决问题的一种思维模式。 在以后开发中，先找对象，调用对象中的具体功能。如果真的没有能够完成需求的对象，这时就自己 创建对象，并将所需的功能定义到对象中，方便以后使用
类和对象的区别是什么/strong>
1，类是一个抽象的概念，它不存在于现实中的时间/空间里，类只是为所有的对象定义了抽象的属性与行为。就好像“Person（人）”这个类，它虽然可以包含很多个体，但它本身不存在于现实世界上。
2，对象是类的一个具体。它是一个实实在在存在的东西。
3，类是一个静态的概念，类本身不携带任何数据。当没有为类创建任何对象时，类本身不存在于内存空间中。
4，对象是一个动态的概念。每一个对象都存在着有别于其它对象的属于自己的独特的属性和行为。对象的属性可以随着它自己的行为而发生改变。
如何定义一个类、类的属性和方法/strong>
类名 对象名 = new 类名 （）；
如何创建类的对象/strong>
class 类名{
属性1；
属性2；
属性3；
属性n；
public void 方法名（参数）{
功能代码
}
}
数据类型有哪两种别是什么/strong>
基本数据类型（存放在栈中） 引用数据类型（存放在堆中）
第十一天
1、属性的默认值问题
成员变量如果没有赋值，会自动的根据变量类型赋默认值
局部变量如果初始化，则无法使用，代码会 错！！！

2、构造函数
为什么有构造函数：
初始化成员变量

4、this指针的使用
在java类中，存在一个this的指针，该指针会自动在创建对应对象时，默认指向对象，
所以此时this就是这个对象

5、类的成员的初始化顺序：
在初始化对象的时候，首先初始化的是属性，之后才是构造函数
方法是在调用时才初始化的，调用完成后则出栈

6、static关键字
static是java的关键字
被static修饰的成员变量最先被加载内存中
被static修饰的方法、变量都属于类本身，不属于对象，意味着可以直接通过类名来调用
静态方法中不能直接调用非静态方法（加载顺序）
被static修饰的变量，是存放在常量区

7.封装
面向对象的编程中，封装就是指，将类的属性私有化，提供公开的方法去访问的方式，叫做封装
2、怎么私有化属性br> 权限访问修饰符

3、如何实现封装
将属性私有化，提供公开的方法去访问和设置值
将属性私有化，通过private访问修饰符修饰
之后提供公开的get和set方法来操作属性

4、一个标准的java bean书写规范
private 修饰属性
通过公共set和get方法来访问属性

构造函数一般至少有两个，一个没有参数、一个全部参数的

第十二天、
1.eclipse的使用、

封装：将属性私有化private，提供公开的方法来访问的方式

继承：

在java中，子类继承父类，extends 关键字

当子类继承父类后，那么子类就自动的拥有了父类的一些方法和属性

子类可以继承父类被public和protected修饰成员

1、在继承中，子类只能继承父类的被public或者protected修饰的方法或者属性
2、当父类方法不能满足子类的使用是，我们一般重写（覆盖）override方法
注意：重写方法是，修饰符访问权限可以扩大，不能缩小

3、子类再构造的时候，首先调用调用了父类的构造，之后才调用自身的构造
4、super是一个指针，指向子类的父类，
super() // 调用就是父类的构造
super.xxx // 调用了父类的属性或者方法
5、java中不允许使用多继承，Java是单继承机制
如果需要多继承机制，则使用接口解决
6、所有类都共有一个父类 Object

第十三天、
1.final关键字的使用
1、修饰变量，则该变量会变成常量（因为值再不能发生变化）
2、修饰方法，该方法不允许被重写（OverRide），一旦一个方法被final修饰，这个方法就是最后的方法，无法被子类重写
3、修饰类，当final修饰类的时候，该类则无法被继承，不能有子类

内部类：
类的内部定义的叫做内部类
内部类最大的作用就是，访问包含它的类的私有属性和方法

多态：
面向对象存在三大特性：封装、继承、多态
多态就是对象的多种状态
在面向对象中的多态指的是，父类引用，指向子类实例的现象，叫做多态
父类引用指向子类的实例
此时可以使用父类来代替所有的子类

final关键字
变量 —> 常量
方法 —> 无法被子类重写
类 —–> 无法被继承
抽象
父类需要存在某个，但是实现不是必须的，
主要是由子类来实现各自的功能！！！

抽象方法：没有实现的方法抽象的方法， abstract

1、如果某个类中，某个方法没有实现，则需要使用abstract将该方法申明为抽象方法
2、一旦某个类中存在了抽象方法，该类必须申明为抽象类。
3、抽象类没办法直接实例化
4、子类一旦继承了抽象类，必须要实现抽象方法，如果没有实现，则必须将子类申明为抽象类，继续向下传递这种特性

抽象类中可以普通的方法br> 可以
抽象类中可以没有抽象方法吗br> 可以
抽象的必要的条件：
|– 继承
|– 方法重写

接口
在Java中，可以使用interface关键字申明的类，叫做接口
注意：接口中的成员都必须public的，即便没有申明，也是public
接口中的方法都是抽象方法（接口中方法没有实现）
接口不能有实现了的方法（必须都是抽象方法，jdk1.8之前）
接口可以多个实现（ implements TestInterface, MyInterface2）
接口可以继承接口（重点掌握）public interface MyInterface2 extends TestInterface
在jdk1.8之后，接口可以使用static或者default关键字定义实现了的方法

接口的作用：
1、约束、规定
2、对Java单继承的补充

接口和抽象类：
接口是一种特殊的抽象类

接口的命名规则：
接口包的命令规则：
1、第一种情况
1、将接口定义在包中 UserDao.java
2、接口的实现类一般方法该包的下一层 xxxxx.impl UserDaoImpl.java
2、第二种情况
将接口和实现类放在一起
IUserManager
UserManager、

第十五天、
异常

面试题1:
请解释下 final finally finalize 三者的作用和区别

1. final

在java中，final可以用来修饰类，方法和变量（成员变量或局部变量）。下面将对其详细介绍。

1.1 修饰类

当用final修饰类的时，表明该类不能被其他类所继承。当我们需要让一个类永远不被继承，此时就可以用final修饰，但要注意：

final类中所有的成员方法都会隐式的定义为final方法。

1.2 修饰方法

使用final方法的原因主要有两个：

(1) 把方法锁定，以防止继承类对其进行更改。

(2) 效率，在早期的java版本中，会将final方法转为内嵌调用。但若方法过于庞大，可能在性能上不会有多大提升。因此在最近版本中，不需要final方法进行这些优化了。

final方法意味着“最后的、最终的”含义，即此方法不能被重写。

注意：若父类中final方法的访问权限为private，将导致子类中不能直接继承该方法，因此，此时可以在子类中定义相同方法名的函数，此时不会与重写final的矛盾，而是在子类中重新地定义了新方法。
1.3 修饰变量

final成员变量表示常量，只能被赋值一次，赋值后其值不再改变。类似于C++中的const。

当final修饰一个基本数据类型时，表示该基本数据类型的值一旦在初始化后便不能发生变化；如果final修饰一个引用类型时，则在对其初始化之后便不能再让其指向其他对象了，但该引用所指向的对象的内容是可以发生变化的。本质上是一回事，因为引用的值是一个地址，final要求值，即地址的值不发生变化。

final修饰一个成员变量（属性），必须要显示初始化。这里有两种初始化方式，一种是在变量声明的时候初始化；第二种方法是在声明变量的时候不赋初值，但是要在这个变量所在的类的所有的构造函数中对这个变量赋初值。

当函数的参数类型声明为final时，说明该参数是只读型的。即你可以读取使用该参数，但是无法改变该参数的值。

在java中，String被设计成final类，那为什么平时使用时，String的值可以被改变呢/em>

字符串常量池是java堆内存中一个特殊的存储区域，当我们建立一个String对象时，假设常量池不存在该字符串，则创建一个，若存在则直接引用已经存在的字符串。当我们对String对象值改变的时候，例如 String a=“A”; a=“B” 。a是String对象的一个引用（我们这里所说的String对象其实是指字符串常量），当a=“B”执行时，并不是原本String对象(“A”)发生改变，而是创建一个新的对象(“B”)，令a引用它。

2.finally

finally作为异常处理的一部分，它只能用在try/catch语句中，并且附带一个语句块，表示这段语句最终一定会被执行（不管有没有抛出异常），经常被用在需要释放资源的情况下。（×）（这句话其实存在一定的问题）

很多人都认为finally语句块一定会执行，但真的是这样么案是否定的

只有与finally对应的try语句块得到执行的情况下，finally语句块才会执行。以上两种情况在执行try语句块之前已经返回或抛出异常，所以try对应的finally语句并没有执行。

但是，在某些情况下，即使try语句执行了，finally语句也不一定执行。
我们在 try 语句块中执行了 System.exit (0) 语句，终止了 Java 虚拟机的运行。那有人说了，在一般的 Java 应用中基本上是不会调用这个 System.exit(0) 方法的。OK ！没有问题，我们不调用 System.exit(0) 这个方法，那么 finally 语句块就一定会执行吗/em>

当一个线程在执行 try 语句块或者 catch 语句块时被打断（interrupted）或者被终止（killed），与其相对应的 finally 语句块可能不会执行。还有更极端的情况，就是在线程运行 try 语句块或者 catch 语句块时，突然死机或者断电，finally 语句块肯定不会执行了。可能有人认为死机、断电这些理由有些强词夺理，没有关系，我们只是为了说明这个问题。

finally用法特殊，所以会撤销之前的return语句，继续执行最后的finally块中的代码。

3.finalize

finalize()是在java.lang.Object里定义的，也就是说每一个对象都有这么个方法。这个方法在gc启动，该对象被回收的时候被调用。其实gc可以回收大部分的对象（凡是new出来的对象，gc都能搞定，一般情况下我们又不会用new以外的方式去创建对象），所以一般是不需要程序员去实现finalize的。
特殊情况下，需要程序员实现finalize，当对象被回收的时候释放一些资源，比如：一个socket链接，在对象初始化时创建，整个生命周期内有效，那么就需要实现finalize，关闭这个链接。

使用finalize还需要注意一个事，调用super.finalize();

一个对象的finalize()方法只会被调用一次，而且finalize()被调用不意味着gc会立即回收该对象，所以有可能调用finalize()后，该对象又不需要被回收了，然后到了真正要被回收的时候，因为前面调用过一次，所以不会调用finalize()，产生问题。 所以，推荐不要使用finalize()方法，它跟析构函数不一样。

finalize() // 该方法在对象被垃圾机制回收前，最后被触发
equals() // equals 比较两个对象是否相等
equals方法底层真正比较的是两个对象的内存地址（）
public boolean equals(Object obj) {
return (this == obj);
}
// equals()

在String类，我们可以直接调用equals比较两个字符串，因为String类重写Object的equals方法

hashcode() // 返回对象内存地址的hash值

最佳建议：
在编程中，一般比较对象，需要重写hashCode、equals

异常：
1、什么是异常
代码运行过程中，或者编译过程中，因为用户的不当操作，或者其他的因素干扰，
导致程序出错的现象，叫做异常
2、处理异常的目的
让程序继续运行，同时提醒用户
3、常见的异常
ArithmeticException
4、什么是异常：
子啊java中异常就是类
一旦代码出现了异常，程序就会被终止掉
5、java中处理异常的方法：
1、不处理 抛给调用者
2、使用try catch 语句块尝试着抓取异常

6、异常对象中的两个方法
// 打印异常触发的栈信息
e.printStackTrace();

// 获取异常信息
e.getMessage()
7、try catch的运行流程

8、try catch finally
try {

} catch (ArithmeticException e) {

} finally { // 一定要执行的代码块
// 不管是否存在异常，finally中的必须执行
// 资源释放等工作凡在finally
}
———————————————————-
try {
} finally {
}

1、什么是异常
2、如何处理异常
|– 捕获异常
|– 抛出
3、捕获异常的操作
try {
// 可能发生异常的代码

} catch(xxxException e) {
// 异常发生时，需要执行的代码
} finally {
// 必须执行的代码
}
4、try语句块的顺序

5、常见的异常
ArithmeticException
NullPointException
ClassCastException
下标越界异常
…

6、使用多个catch进行多次异常的捕获
注意：当捕获到一个异常后，其他异常就没法办法捕获了 7、异常继承关系
Throwable
8、异常抛出（throws关键字的使用）
第二种处理异常的方式
在方法的名称后面使用throws 抛出异常，将可能出现的异常抛给调用者
有调用者来处理异常，如果调用者也不处理异常，则继续向上抛，最后如果都不处理
则会有main函数抛给JVM
9、自定义异常的使用
当jdk提供的异常不够我们使用的时候，我们需要自定义异常
建议继承RuntimeException

10、异常类型
编译型异常： 在编译时，必须处理的异常 Exception
非编译型异常： 在运行的是，抛出的异常， RuntimeException 或者它的子类

11、人为抛出异常
人为抛出异常，一般都是为低层为高层传递信息

第十六天、
Java有8种基本数据类型，为什么又要出现对应的8种包装类：

1、Java的8种基本数据类型不支持面向对象编程机制

2、8种基本数据类型不具备“对象”的特性：没有成员变