JavaSE总结

我就是我 2022-04-22 07:22 170阅读 0赞

亲身经历后的总结+视频老师辅导+目前工作实践

## **Day1-学习方法及编程思维** ##

1.  **学习可能遇到的问题**

问题：

总是感觉模糊，懵...

1.每天学习的内容都是崭新的，前面知识点，相关性不是很大！每天都是细节！内容多（10天）

2.概念：理解！细节

没思路：

1.老师的代码看的懂！基本都是抄！

2.理解不够，基本工作没有做够！【多练习，熟悉基础知识】

1.  **学习的方法**

1.当天的内容为重，必须完成，理解，练习，总结

1.理解：写注释，写说明

2.练习：多练习,写明白了，再加上适当的变化，看看是否如自己预期一样！

3.总结：后期回顾，自己能够立马看懂！归档！整理

2.注释：说明

1.知识点必须说清楚

2.每个细节【1，当天的知识，2，发现之前的知识，适当的注释】

3.总结：归档！整理

4.文件整理

5.预习：看看接下来要讲什么课程(看大纲就好)

3.学习套路(脚踏实地)

I．看懂代码细节写注释

Ii.看懂代码执行流程(从主方法开始看)

Iii.从一定高度看懂代码结构(每一块是做什么的)

Iiii.从高度再看细节(知道每一个代码都在做什么)

如下基础巩固 必要！

从基本语法的角度看代码

从面向对象的角度看代码

1.  **编程逻辑思维：**

1.  **变量：**用来存储数据，被计算机命名的内存区域，就相当于储物柜。特点：一次只能存一个值，不能再存其他的值
2.  **程序的执行过程：**

**a****顺序、选择、循环**

## **Day2- 环境搭建** ##

1.  **什么是计算机**

是一种能够按照程序运行，自动、高速处理海量数据的现代化智能电子设备【所以计算机会按照我们自己写的Java代码去处理数据】

计算机由软件、硬件两部分组成（软件又分为系统软件 和 应用软件）

系统软件：主要目的是跟磁盘打交道，为了方便操作计算机而开发的软件，本质软件

应用软件：主要提供给用户使用，应用软件依赖操作系统运行.例如：QQ、微信、浏览器……等等

1.  **软件开发步骤：**

*  需求分析：需求文档，需要客户签字

②系统设计(axure)：系统设计师完成设计

③实现

④测试

⑤实施

1.  **系统环境的介绍**
    
    1.  电脑的盘符
    2.  Windows 常用的快捷键：Ctrl+z:撤销、Ctrl+y:反撤销、Tab: 缩进：调代码格式：规范代码编写、shift+Tab：反缩进

5. DOS(命令提示符)：DOS是Disk Operation System的简写。意思是“磁盘操作系统”，DOS主要是一种面 向磁盘的系统软件.

切换盘符：盘符名称 +** ****英文的冒号**进入目录：cd + 目录名称（或目录路径）可以输入tab 键补全

绝对路径：是从盘符开始的目录路径 相对路径：是从当前目录开始的路径

cd  目录 à这个目录必须是当前盘符下，如果要进入不同盘符的目录，必须先切换到目标目录所在的盘符下再操作。

dir： 列出当前目录下的文件以及文件夹 md：创建目录 rd： 删除目录 cd： 进入指定目录

cd..：从当前目录退回到上一级目录 cd\\：从当前目录退回到根目录（当前盘符就是根目录） del：删除文件

exit：退出dos命令行 help

**4.环境变量：**当在磁盘的某个目录，希望运行某个命令【应用程序】的时候，如果在当前目录，不存在该软件，会到环境变量配置的目录下面去查找该命令，如果存在就运行，不存在，找不到该命令！

环境变量配置的作用：可以让配置的命令，在计算机的任何位置都可以运行

### **5.与java相关的环境变量** ###

A：Path：配置一个可执行应用程序的路径 的环境变量。

B: JAVA\_HOME: 配置jdk安装路径 的环境变量

1.  Java跨平台原理（理解）

**6.****Java****的跨平台**：一个应用程序可以运行在多个平台，与平台无关

B:  java借助于一个Jvm叫的东西（JVM：jvm虚拟机）

1.  Editplus工具的使用以及软件设置

1.  安卓后，工具-参数配置-模板-java  ；javac（编译）  java（运行） 到软件中去
2.  去掉备份bak文件 ： 工具-参数配置-文件-不勾选保存时创建备份文件

### **7.工具是如何进行编译的** ###

1. 编译:通过快捷键操作，通过代码源文件的文件名字找到文件，编译文件内容

2.运行:通过快捷键操作，通过源码文件文件名字，不需要后缀名，找对应的class文件

### **8.Java注释** ###

1.作用: 注释其实可以看成是备注，代码运行的时候是不会管注释内容的，可以增强代码的可读性。

## **Day3-基础知识** ##

### **1. java注释** ###

①//单行注释（以行终止符为准）

②/\*   \*/   多行注释，可以解释多行

③/\*\*   \*/ 文档注释，可以注释多行，特点：可以通过一个命令javadoc把文档

注释中的内容生成文档

注意：多行注释和文档注释不能相互嵌套

### **2.什么是分割符** ###

分号（;）：表示一句话结束，相当于句号

花括号（\{ \}）：表示一个代码块，是一个整体，要成对使用

方括号（\[ \]）：定义数组和访问数组元素时使用。

圆括号（( )）：使用广泛，具体用到细讲

圆点（.）：类和对象访问它的成员时使用

注意：必须都是英文符号

### **3.关键字\[特点小写,java赋予了特殊意义\]** ###

public  class  Boolean  break  byte  case  catch  char  assert  const

continue  default  do  double  else  enum  extends  final  finally  float

for goto if  implements import  instanceof  int  interface long native new

package private protected abstract return strictfp short static super switch

synchronized this throw throws transient try void volatile while

特点：所有的字母全部小写

### **4修饰符** ###

public 类

变量

方法\[区分构造方法,普通方法\]

对java当中的类，变量，方法，构造方法等等进行修饰，赋予被修饰

内容特殊意义

标识符：java所有的组成部分都需要名字，类名，变量名以及方法名都被称为

标识符。

①所有的标识符都应以字母（A-Z或a-z），（$）、或下划线（\_），开始。与数

字构成（不能以数字开头）

②关键字不能用作标识符，标识符大小写敏感的

书写规范：类名首字母必须大写，方法名，变量名首字母小写，如果由多个单词

组成，后面每一个单词首字母大写

### **5.数据类型** ###

数据类型包括基本数据类型和引用数据类型

整数类型:byte short int long

①基本数据类型：数值型（整数类型：byte,short,int,long）（浮点：float,double）

字符型（char）布尔型（booleam）

引用数据类型：类（class）接口（interface）数组

整型：byte（-128~127）short,int,long

注意：给long赋值时，因为整数默认是int类型，要转换为long类型的值，后面

加上L

默认的进制10进制，二进制：是0b或0B开头，八进制：是0开头

十六进制：0X（0x）开头

②浮点型：float，double

float：单精度32位。直接赋值时必须在数字后面加上f或F

double：双精度64位。

区别：对于单精度浮点数，运行速度比double快，占内存更小，但是当数值

非常大或非常小时会变得不精确。双精度比单精度表示的位数大，精确的位数

多，简单说float表示的小数点位数少。

默认浮点数的类型是double

注意：表的时候会有精度损失

结论：浮点运算很少是精确的，只要是超过精度能表示的范围就会产生误差。

往往产生误差不是因为数的大小，而是因为数的精度。因此，产生的结果接

近但不等于想要的结果。

③整数数据：默认类型为int类型：如：13默认为int类型

小数数据：默认为double类型：如：3.14默认为double类型

④自动类型转换：小数据类型转大数据类型（存储空间的大小）

强制类型转换：大数据类型转小数据类型（存储空间的大小）

相同存储空间不同类型表达值范围不一样（如char及short）

1.  **数据类型的转换**

整型数据 ： 默认类型为int类型 小数数据 ： 默认为double类型

自动类型转换：小数据类型转大数据类型【存储空间的大小】

强制类型转换：

①大数据类型转小数据类型\[存储空间大小\]

②相同存储空间不同类型表达值范围不一样\[例如：char及short\]

类型转换：

①小转换到大（除了short和char ,因为表示值的范围不同，不能自动转换）其他都可以自动完成转换

②而从大到小，必须强制转换。（高 转 低会导致精度丢失,不同类型的强制转换，可能会导致精度的下降）

*  char 不能和byte short 相互自动转换

面试题：引用数据如何转换，有什么注意事项，举例说明

引用数据类型：int = Integer

char = Character

double = Double

long = Long

flort = Flort

byte = Byte

注意事项：

1：java开发过程中整型用int、小数用double、布尔用boolean；

2：类型转换都是小范围向大范围转换，大范围往小范围转化需要用到强制转换；

例如：(1)int a=12;double b=a;(2)double a=3.0;int b=(int)a;

3:long,byte,char等很少用到，一般在数据处理的时候会用到；

4：int跟char之间的转换是通过ASCII转化的；

例如：char a ='A';int b=a;System.out.prientln(b);最后输出的结果为65；

5：String类型，String是项目中必不可少且使用最多的数据类型，它属于引用数据类型中“类”的范畴。

### **7常量转义符** ###

常量：Java中的常量，常量就是一个固定不变的量（或者值）

分类：① 整数常量     例如：100 600L   ② 小数常量    例如：1.3   2.5   2.1F

③ 字符串常量   例如：”你好” “④ 字符常量   例如： ‘A’

⑤ 布尔常量    true false  ------>上面的5中表示形式的常量都可以直接放在打印语句中打印

常见的转义符：①\\r表示接受键盘输入，相当于按下了回车键； ②\\n表示换行；

③\\t表示相当于Table键制表符   ④\\b表示退格键，相当于Back Space键；

⑤\\'表示单引号 ⑥\\''表示双引号 ⑦\\\\表示一个斜杠\\

1.  **变量**

变量：变量就是一个容器（**特点**：一个变量在同一时间只能存储一个数据。）

变量的语法格式：数据类型 变量名；

变量的分类：

①成员变量：l成员变量如果没有赋值，那么系统会分配默认值（不同的数据类型有不同的默认值，这点请参考数据类型）；

作用域范围：整个类中可以访问的范围；可以放在方法的上面 ，也可以放在下面

②局部变量：直接声明在方法内部,比如main方法的形参 或者 大括号中

1.  **表达式**

l 含义：由一系列的常量变量运算符，括号()组成的一个算式，为了按照一定的运算规则计算出结果值.

任何的一个表达式都是有一个结果值的，可以定义一个变量存储

表达式的结果值的类型   取表达式中操作数类型精度最高的

## **Day04-Java运算符选择结构循环结构** ##

1.  **运算符**

加法（+）减法（-）乘法 （\*） 除法(/) 取模(%)

String使用+法是字符串连接

2)自增自减

\++     --

自增自减只能够用于**变量**，不能用于常量

自增自减运算的优先级比算术运算符高

自增重要知识点：

①变量使用自增运算符，对自身进行自增

②自增运算符写在左边或者右边，都会对变量自身加1

③自增在左边则先自增

④使用自增运算表达的结果：方式通过其他的变量来接收表达式的结果

1.自增运算符在右边！

a.k肯定会自增

b.表达式的结果为k自增之前的值

2.自增运算符在左边

a.k肯定会自增

b.表达式的结果为k自增之后的值

（如果有需要赋值给m，自增在右边，会先自增但是系统会先缓存表达式的值给m；如果自增在左边，则先自增后，缓存表达式的值给m）

1.  **赋值运算**

1. 赋值运算的符号：=  +=  -= \*= /= %=（注意：赋值运算顺序，是从右往左）
2. 比较运算符：==    !=     >  <    >=    <= （注意:比较运算符的表达式运算结果类型为：boolean:结果 为true或者false）

instanceof : 类型比较运算符【理解就是一个运算的符号】

①该运算符是比较类型：【比较对象的类型】

②只能用于引用数据类型的，类型比较【不能用基本数据类型】

使用：值/变量/表达式 instanceof 类型

3.逻辑运算符：&（与） |（或） &&（双与） ||（双或） ^（异或） ！（非）

作用：是应用于多个条件的组合判断（判断的时候使用，参与运算的类型和结果类型都为boolean）

&：两边都是true结果才是true

|：只要有一个为true结果为true

&&：两边结果为true，结果为true:（BUG：如果第一个结果为false后面直接不再运算）

||：其中一个为true,结果为true：（BUG:如果第一个结果为true，后面不再运算）

4. 位运算 含义：位运算：二进制位：针对于二进制位的运算 &    |    ^     ~    <<>>>>>

5.三目运算符：x ? y : z;分割的三个表达式（如果x为true则Y 的结果值、否则为Z的结果值）

①X ?  布尔类型的值或者结果为布尔类型的表达式

②Y  Z  ?   一般来说数据类型相同的值或者表达式

运算规则: X 为true，就是 Y 的结果值 ( 冒号前面的表达式的值)：也就是整个三目运算的结果值

X为false，就是Z的结果值 ( 冒号后面的表达式的值)：也就是整个三目运算的结果值

6. 条件选择结构-switch:

switch选择结构

switch(x)\{//值，变量或者表达式：类型：Java已经规定好的类型

case 值1:

功能语句

break;

case 值2:

功能语句

break;

case 值3:

功能语句

break;

default:

功能语句

break;

1.执行顺序，是先依次找完所有的case值\[与switch后面小括号的值进行匹配\]进行匹配,

①如果匹配成功：会执行case后面功能语句，遇到break;选择结构结束

②如果都不匹配才会执行default，遇到break结束

2.case后面的值应该和变量的类型一致;

3.case的顺序（包括default） 可以是任意的，但是建议先按照case的值的大小顺序排列，default放最后

4.最后的一个语句case或者default执行完毕了，可以不用写break;\[到了最后一句也是结束了\]

5.break的作用，结束当前的这个switch结构,果一个case或者default匹配执行了，在遇到第一个break之前， 的case失效

7. while基本用法

1. while语法格式:

<table style="margin-left:40.85pt;width:412pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:412pt;"> while(条件（布尔类型的）){ // 循环体à具体做什么事情 } </td> 
 </tr> 
 </tbody> 
</table>

2.while如何进行条件判断

1.  条件可以是一个常量(条件为布尔值true)
2.  一般我们使用一个变量来充当条件循环，

一个循环可能会循环执行多次

1.  第一次判断条件true，继续执行
2.  第二次判断条件true，继续执行
3.  第三次判断条件true，继续执行
4.  。。。。。
5.  直到第n次判断条件false，终止循环

为什么第一次第二次是true .........第n次就是false?

定义一个整数的变量记录循环的次数----》循环一次，自增一次--->据次数进行判断

### **3. do-while 基本用法\[掌握\]** ###

1.语法格式

<table style="margin-left:45.65pt;width:391.1pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:391.1pt;"> do{ // 循环体 }while(条件); </td> 
 </tr> 
 </tbody> 
</table>

2.do-while

1.  首先执行do结构体里面的功能代码一次
2.  第一次判断while()结果为ture
3.  执行do循环体.......
4.  第二次判断while()结果为ture
5.  执行do循环体.......
6.  .......
7.  第n次判断....while().....flase循环结束

很多都是上课的时候能理解 自己做的话就没有思路 不知道怎么去开展，和对各种知识点的理解运用

## **Day05 for循环、方法** ##

### **1.for基本用法** ###

1.语法格式：for(初始A;条件判断B;循环后操作C)\{

//循环体C

2.执行流程：初始化语句会执行一次；只会执行一次

l     整个for循环结构中的  A 只会执行一次

循环第一次：AàB(true)àDàC

第二次：      B(true) àDàC

第三次：      B(true) àDàC  ......

第n次：        B(false)  结束整个循环

### **2.嵌套循环\[掌握\]** ###

概念：循环里面还有循环，可以嵌套多层，不同的循环结构相互之间也可以嵌套

语法格式： for()\{

for()\{

### **3.循环控制语句\[掌握\]** ###

1 break循环控制语句：表示终止当前当层循环

特点：①终止循环 ②终止当层循环【break写在那个以循环里面的，就终止那一层循环】

③测试如何在内部终止外层循环【给外层循环区一个名字】

2. continue循环控制语句：  跳过本次循环，继续下一次循环

3. return：表示结束当前的方法，方法整个结束！【方法整个停止运行】

### **4. 方法\[掌握\]** ###

1.概念：也叫函数，就是在类中的一个代码块，独立完成功能【独立的功能代码块】

注意：功能代码块！独立的代码块，可以反复的使用的！每次的使用是独立的

2. 方法的语法： 修饰符 返回类型 方法名字(数据类型变量名，数据类型变量名,……)\{

//在方法的代码块区域返回结果值的语法：

return  返回和方法返回类型相同的值；

注意事项

①：静态方法不能引用非静态的方法

②：参数在方法设计的时候，可以不使用

③：使用方法，传参数的【个数】【类型】【顺序】都必须与方法的定义参数一致

④：对象名.方法名+参数列表【个数，类型，顺序】都必须一致

⑤：命名应该见名知意：所以加法的方法名字应该都为add

⑥：方法被调用的时候才会执行

l ⑦：可以重复的调用执行(多次调用相互之间没有关系，各自调用各自的)

方法如何使用：三条规定

①如果一个方法有static修饰：使用类名.方法名+参数列表【个数，类型，顺序】都必须一致

②方法如果在同一个类中：直接使用方法名+参数列表【个数，类型，顺序】都必须一致

③如果一个方法没有static修饰并且没有在一个类中【在别的类中，使用该类的没有static修饰的方法】

**方法签名**：方法名字+参数列表【参数列表包含：个数，类型，顺序是否相同】

### **5.方法return** ###

1. \[区分循环控制语句return\]

1) 方法里写上return 返回值（定义个sum变量存放求和的结果并返回）

return  sum;//表示把sum变量中的值返回给调用者

2) 修改返回类型

方法的内部返回了一个数据，数据的类型是int，所以void 修改成 int

注意：把sum变量中的值返回给调用者，不是返回sum这个变量

3) 方法里面返回的变量sum 值，是否可以在调用的方法里面直接使用？

l 方法里面的变量sum只能在所在方法里面才能访问，其他方法不能访问

4) 怎么获得结果值?

l 把add方法这个整体  看成是 此方法计算完毕的结果值

a) 直接把  方法整体  放在打印语句中打印（把方法看成是整体）

b) 可以定义一个变量接收 方法结果值

c) 把方法整体看成是一个值，参与运算

**①**对于结构体语句中写返回值：**编译检查语法，只看结构不看值：**

②如果一个方法的返回类型不是void，那么要求（不管方法里面做了什么事情）都必须返回

一个和 返回值类型匹配的值

### **6.方法重载(overload)** ###

1. 方法重载：在同一个类中，方法名字相同，参数列表不同【个数，顺序，类型】

好处？方便

F 如果一个类中存在了多个名字一样的方法而编译不报错，那么肯定就是重载

注意：方法重载和参数名字没有关系。和 返回值类型 和 修饰符也没有关系

## **Day06-数组** ##

1.  **数组**

1概念：可以定义一个变量容器，存放多个数据，连续的存储空间，里面可以按顺序存放多个类型相同的数据。

2.结构 数组元素：就是存放在数组里面的数据

数组索引：就是数组里面每个数据的编号，从0开始

获得数组【连续存储空间的基本语法】

①动态获取数组

1.定义的同时赋值

数据类型\[\] 数组名 = new 数据类型\[值\];//值数组长度，数据类型

int\[\] arr = new int\[10\];

2.先定义后赋值

数据类型\[\] 数组名;

数组名 = new 数据类型\[值\];//值数组长度，数据类型

②静态获取数组\[最大特点：定义的同时可以给数组存储空间赋值\]

3.数组的特点：

①数组一旦创建好了，长度就不能改变！

②数据类型，限定了连续存储空间，可以存值的类型

③数组连续存储空间：会根据数据类型，存在默认值！

③一个数组的长度：数组具有一个属性length:怎么使用？

数组名.length

⑤如果操作存储空间的范围：超出了索引，会出现异常索引越界！

4.怎么使用：本质的目的是使用的连续的存储空间

a存值的：数组名\[索引值\] = 值

b取值：数组名\[索引值\] （可以变化控制循环的变量的值，通过该值作为数组索引，依次取到所 有的值）

### **2.java存储数据分析** ###

堆：可以理解为凡是new 出来的东西都放在这里面

栈：主要存放一些变量容器名 （例如局部变量名，还可以存放局部变量 基本类型 数据值），栈内存被要求存放在其中的数据的大小、生命周期必须是已经确定的

### **3.数组操作** ###

3.1冒泡排序

3.2二分搜索(了解)

特点：被查找的数组中的元素必须是有序的

二分查找：通过打印存在多个相同数据的数组，二分搜索的位置可能不准确【bug】

1.  **方法参数传递\[掌握\]**

1.值传递：形式参数类型是基本数据类型

方法调用时，实际参数把它的值传递给对应的形式参数，相当于拷贝了一份值给形式参数， 所以方 法 执行中形式参数值的改变不影响实际参数的值。

2.值引用：引用传递其实传的是地址，形式参数类型是引用数据类型或数组。

注意：方法调用时，实际参数是对象(或数组)，这时实际参数与形式参数指向同一个地址

在方法执行中，对形式参数的操作实际上就是对实际参数的操作，这个结果在方法结束后被   保留了下来，所以方法执行中形式参数的改变将会影响实际参数。

引用类型的变量在传递的时候，其实也是变量中值（这里的值看成存储对象的引用地址）

## **Day07数组加强和面向对象** ##

### **1. Arrays工具类&API文档的使用【掌握】** ###

A:工具类概念：工具类：Java开发者把经常使用的功能帮我们写好成一个类，这类里面已经实现了提供很多工具方法，供我们使用;

b:Arrays工具类的引用：

像是升序，搜索，排序等等比较具有代表性的 Arrays工具类，Java已经帮我们写了

我们在使用的过程中可以直接调用

C:API文档的使用：

①通过文档找到我们需要使用的类和方法

②看这个方法是否有static修饰--》决定调用方式

③看形参(调用此方法需要什么条件)

④看结果(有些有返回值，有些没有)

### **2.增强for循环** ###

1作用： 主要是用来遍历数组和集合的；

2缺点： 没有索引，凡是涉及有索引相关操作还是用普通for循环，

3. for循环语法

for(源中元素类型 变量名  ： 源 )\{

//可以通过变量名使用源中的每一个数据

特点：①源：可以是数组，集合(Iterable接口实例）

②源中的数据类型：例如数组int\[\] arr = new int\[5\]；arr中的数据类型是int

③e：形式参数：在使用foreach遍历数组的过程中！通过形式参数，使用到数组中的每一个元素

### **3.可变参数** ###

1.概念：可变参数是可以变化的参数，参数的个数可以是任意多个

2.使用方法：写在方法里面形参里面 比如：方法名(参数类型... 变量)  ...为固定格式

3.特点：①打印的时候发现：是一个地址

②传入的是int类型的多个数据！最近学习的打印地址，能够一次传入多个数据的类型是数组

③经过测试：发现调用方法的时候，将传入的多个数据，打包成数组，在方法的内部可以当作数组使 用

4.可变参数的注意事项：

①可变参数类型，与普通方法类型，如果名字及参数表一致会报错！不能同时声明

②int ... i:可变参数语法规定只能是三个点

③可变参数的前面，可以写其他的参数

④可变参数的前面，不可以写可变参数

⑤可变参数的后面，不可以写普通参数

⑥一个方法 可以有可变参数和普通参数，但是可变参数必须放到参数列表的最后；

⑦一个方法 不能有多个可变参数；

1.  **面向对象**

1. 面向对象 ： 就是一种**编程思想**

2.java在设计语言的时候,希望能够将现实生活中,对象之间的关系在计算机中得以体现所以有了面向对象编程的思想!

3.人类思考问题,总是从简单的角度出发,发现,现实生活中,所有的事物,都可以分类!所有类的事物,我们发现,其实可以分为,动态属性,静态属性两大部分

4.认识什么是类,什么是对象!

发动机生产厂商-----à发动机

人类-----à具体的一个人

学生类---à具体的一个学生

1.  开发了一个学生管理系统

纸质模板\[描述的一个类事物\]-----------------------à复制模板\[填写值\]\[描述的一个对象\]

1.  在计算机中,需要类-----à对象!

在java代码中,如何能够去体现,类!\[静态属性,动态属性\]

1.  java中有已经提供了类

class Student\{//该类,描述了学生这一类的事物

String name;//静态描述学生姓名

int age;//静态描述学生的年龄

void eat()\{//动态描述学生吃的行为

1.  通过类得到对象

new Student();//通过Student类的无参数的构造方法,得到的一个游离在堆中的匿名对象\[本处本质就是一个学生对象\[ 再次 new Student().name拿不到值\]

1.  Student stu = new Student();//stu持有studetn的地址,指向该对象,对该对象进行引用

stu.name = “----”;

stu.name

\------------------------------------------------------------------------------------------------------------------------

通过自己在计算机中设计的一个类，也就是Java的类，来得到对象

复制模板的过程

将类看成是模板，复制一份，就是一个对象！

## **Day08面向对象概念** ##

### **1. 类和对象理解** ###

1.** 类 ：**是指描述一类事物，或者看成是一个分类， 例如人类、车类、星球类,

2.** 对象 ：** 是指具体的个体（也叫实例-instance）,具体的事物

### **2设计类** ###

1. 如何设计类

①java中的类，就是类！用来描述一类事物，任何事物包含：静态属性，动态属性

②通过设计类，可以用来描述一类事物

③如何设计：静态表现：成员字段 动态表现：方法

④设计类语法：class 类名\{

方法 （具体的一个功能行为）

成员变量  (字段)

2.注意事项： 1.类名首字符大写例如：Student 1. 类名必须具有意义 3. 必须写注释

### **3.对象的创建** ###

1.如何创建对象：类型 变量名 = new 类名() 比如 Student stu = new Student();

2.给对象字段赋值\-->对象名.字段名 比如 stu.name=”Xxxx”;

取值：--》对象名.字段名 比如 stu.name

### **4.构造方法（Constructor）** ###

1.构造方法：构造方法是跟普通方法很类似的一个结构

2.构造方法的特点：

①构造方法的名字，跟类名一致的。

②构造方法是没有返回值的【构造方法的位置】

③构造方法的内部也不需要返回值

④构造方法：可以有修饰符

⑤构造方法可以有形式参数

⑥构造方法也是方法：就可以功能；所以构造方法被使用了，那么里面的功能代码就会执行！

3. 类中构造方法特点：

① 每一个类中都至少有一个构造方法;

② 如果没有看到（显示的），那么存在一个隐式的无参数的构造方法;

③ 如果一个类中有显示的构造方法，那么隐式的就不存在了;

4.构造方法的作用：

① 通过调用构造方法可以创建对象

② 在创建对象的同时给对象的字段赋值

5.构造方法注意事项：

**① 普通方法可以名字和类名一致，但是不推荐这样，容易混淆;**

② 构造方法的调用方式和普通方法不一样

**构造方法调用：目前通过new关键字调用**

**普通方法调用：**

1.普通方法看有没有static 修饰，有----》类名.方法名   没有----》对象名.方法名 2.在同一个类中：方法名+参数列表

3.静态的方法，不能调用非静态的方法！

③ 把构造方法 Student  写成小写了 student；

6. 目前为止，一个类中可以有的成员：

①成员变量【成员字段】是写在类的结构体中的，所以成员成员字段式类成员

②构造方法也是类中的一个成员

③普通方法也是类中的一个成员

### **3.匿名对象以及对象的生命周期** ###

1.匿名对象的概念：

a.匿名对象，就是没有名字的对象\[创建了一个对象而没有使用变量接收\]

b.该对象存在于堆总处于游离状态：没有任何变量指向他

2.匿名对象的作用：

①匿名对象作为参数传递

②匿名对象本身就是一个对象，所以可以调用自己的属性例如：new Student().name : int\[\] arr  =\{1,2\};arr.length

③匿名对象可以作为返回值

3.匿名对象的使用场景：

①只使用一次(比如 new Student().eat())

②可以作为一个方法的实际参数 test(Student stu) --> test(new Student())（了解）

4. 对象的生命周期（了解）：开始 : new Student()  ，new的时候就开始了；

结束（说法1，常见的说法） ：当对象失去所有的引用（没有变量再指向它了（没有变量在存储它的地址） \- 相 当于失联了，我们无法再使用它了）-- 就是死亡了

结束（说法2） ： 对象真正的被销毁（对象会在堆里面占用内存，当把对象的内存空间回收了），

**Java有自动垃圾回收机制:****Java自己的一种机制,会把对象占用的内存空间回****收****,对象就被销毁了!**

### **4.static关键字  静态的** ###

1. static是修饰符：可以修饰的内容：

①普通方法，

②字段（不包括局部变量）

③不能修饰 局部变量 外部类 构造方法

2.修饰字段：如何访问：

1.有static修饰的字段应该是字段所在 类名.字段名 进行访问

作用:该字段被该类的所有对象共享:

2. 没有static 修饰的字段： 字段所在的类的对象来访问

3.修饰方法：如何使用：

1. 有static修饰的方法： 方法所在的 类名.方法名(...);

作用:一般修饰工具方法:如果需要对象调用创建对象,非常消耗资源的

2. 没有static修饰的方法 ： 方法所在的类的对象名.方法名(...);

4.全局变量【字段】：可以

1.作用：静态字段，被该类的所有对象共享！

2.一个类，描述一类事物-----》通过类可以得到具体的对象：【该对象就是描述的一个具 体的事物】

3.一个字段，什么时候适合用static修饰！

全球人口数量

圆周率

5.普通方法作用：可以不用创建对象，直接通过类名.方法名+参数列表调用方法，使用方法的功能，很方便

6..一般什么普通方法，比较适合用的static修饰: 类中的工具方法！

### **5. 包** ###

1.包：就是管理类文件

2. 一个类管理：包应该在哪里声明：Java源文件的最前面【应该是在代码的最前面】

3.包的使用和注意事项：

a.目前学习包的阶段：编译运行不是通过editplus工具,而是通过命令的方式

编译：javac -d . 类名.java

运行：java 包.子包.子包.类名

类的完全限定名 ： 包名.子包名.类名**（如果在一类中，存在使用不同包，但名****  字相同的类，需要使用完全限定名！）**

b. 包名中应该全部都是英文，并且是小写的

c. 自己一定需要有规范命名的意识，具体怎么写以公司标准为准

4.导入包

1. 包导入的作用：为了方便的使用到声明在某个包中的类

2. 包导入的语法：

import java.util.Arrays;//在当前的类文件中，将Arrays工具类进行了导入

import java.util.\*;//\*通配符.......

注意：包导入，还是需要写在文件的前面

## **Day9-面向对象-封装-继承** ##

### **1. 封装** ###

1.封装的含义：通过给字段或者方法 添加访问权限修饰符 达到封装目的

2. 封装目的：--》为了安全，不能让外部对象轻易的访问，需要提供set/get方法 或者构造方法（重点）

3. 封装的步骤：

a.字段私有化

b.给字段提供 get set方法【存值，取值】

c.javaBean：

标准的java类：

1.  1.  1.  1.  字段私有化 提供get Set方法
            2.  给每一个字段都提供一组getter  setter方法  (方法的规范写法)；setXxx
            3.  并且需要提供一个无参数的构造方法!!
            4.  因为：如果一个类中显示的写了有参的构造方法，无参的构造方法就不存在了
            5.  一个类中的多个字段的赋值方法 写成一个方法 不可取  耦合度太高
            6.  注意 : 如果字段的类型是布尔类型的boolean,那么get方法应该变成 is  其它不变

4. 给对象的字段赋值 一共有哪些方式：

1. 没有私有化:直接访问字段赋值    X 字段一般都会给私有化（私有化访问不到）；

2. 通过构造方法赋值    只能够创建对象的时候赋初始值；

5. 访问权限修饰符： private < 默认不写（注意不要添加default修饰）<  protected < public

注意：a.private：最小权限，被它修饰的成员只能够在本类中可以访问到；

b.public:  最大权限，任何地方和任何人都能访问；

### **2. this** ###

1.this的概念：是一个关键字，具有特殊含义：

1.官方说法“this所在的函数【方法】正在被调用，this就指代谁（this指代当前对象）

2.this当前被哪个对象使用持有，this就指代谁（this指代当前对象）

2.this作用:

a. 区分了局部变量与成员字段的二义性

b. 本类中构造方法之间的相互调用：

在写set/get方法的时候，为了在使用的时候方法，通常也会在new的时候，给name,age赋值，所以通   常还提供构造方法;

this();    表示调用本类中无参数的构造方法

this(...);   表示调用本类中具有指定参数的构造方法

这句话只能够是在构造方法中，并且是第一句

c. 作为返回值返回，this既然表示的当前的一个对象，对象就是一个数据，一个数据就可以作为值被返回

d. 作为参数传递

e. 在构造构造器的第一句调用其它的构造器\[构造方法\]

### **3. 继承** ###

1.继承的作用：需要把类的公共的部分,提取出来,让其他类继承,方便!

2. 继承的基本语法： class A;

class B extends A;

3. 继承可以继承父类的东西：

1.非私有字段【静态，动态属性】

2.继承到类的特性

3.（反射技术，也可以拿到私有的东西.....）

3. 继承的特点：

1. Java中的类的继承只能是单继承，【一个类只能有一个直接父类】（就相当于只有一个亲爹）

2. 可以支持多重继承，可以有N个子类【间接父类】

3. 每个类都有一个直接父类，如果没有看到显示的继承代码,，每个类都是用object作为超类，隐式继承 object【类层次的根类】

### **4. 方法覆写** ###

1. Overload方法重载：在一个类里面方法名相同，参数列表不同（类型，数量 ，顺序不同）

2. 覆写方法的原因：当父类中的一个行为不满足子类需要的时候,在子类中覆写父类中的方法

3. 方法覆写的细节：

1. 保证子类方法和父类方法的方法签名(方法名+参数列表)一致;

1.在一个类中如何找到方法的（方法签名）

2.方法签名：方法名字+参数列表【类型，个数，顺序都一致】

2. 访问权限 : 子类方法的访问权限(修饰符)不能够比父类方法的访问权限更低;

访问权限：private<默认不写<protectad<public

3. 父类static 方法不能够被覆写 ,  为什么呢?  Java规定!

4. 返回值类型 : 子类方法的返回值类型可以是父类方法的返回值类型的子类或者相等

问题代码:  int long根本不是类,int也不是long的子类

5. 方法主体 :  方法覆写,子类方法和父类方法主体是否可以一样, 可以! 但是没有什么用!

6. 在编译阶段验证是否覆写: 在子类方法上面加 @Override ,让编译器来检查,如果是正确的覆写,编 译通过,否则编译报错

### **5. Object类** ###

1. Object类的了解：

类 Object 是类层次结构的根类,每个类都使用 Object 作为超类。(和接口没有关系)

所有对象（包括数组）都实现这个类的方法 : **所有的对象都可以调用到Object中的方法;**

**比如：**

**①Student s = new Student();**

**       **** s.hashCode(); 可以的**

**      ****②String s2 = “等等”;**

**       ****s2.hashCode();可以的**

**      ****③ int i = 5；**

**      **** i.hashCode();//不可以的**

**      ****④int\[\] arr = new int\[6\];**

**      **** ****arr.hashCode();可以的**

### **6. 覆写Object中的方法-toString** ###

①．oSting();//返回对象的字符串描述

②．发现:如果自定义一个类,没有覆写toString方法,打印的是对象的地址\[不符合自定义类对象打印自身信息的需求

*  ．覆写toString:按照自己的规则,覆写需要打印的对象的字符串信息
 *  ．覆写的意义:为了能够方便的打印**自定义类对象**的信息\[通过打印string对象,发现打印的就是String对象的
 *  ．描述,所以java 有些写好的类,已经覆写了toString方法\]

### **7. equals和==的区别** ###

1.  1.  1.  1.  ==
                
                1.  基本数据类型的变量 :比较的是值
                2.  引用数据类型的变量:比较的是地址
            2.   equals:

主要是为了比较引用数据类型的对象是否一致\[参照现实生活中的比较规则\]

基本数据类型比较应该用==

引用数据类型的对象比较应该用equals\[尤其反应在String类\]

### **8.覆写equals方法** ###

使用equals比较对象，应该参照现实生活中的规则，但是Object当中比较的规则就是==比较，不满足对象的需求，所以需要覆写

Equals使用来比较引用数据类型，地址是否相等。

## **Day10-面向对象super-多态-引用类型-final** ##

### **1.访问权限\[了解,不用重点掌握\]** ###

1.  1.  有哪些权限修饰符
    2.  修饰符修饰之后又什么作用
    3.  权限了列表不要记\[谁傻谁记,谁记谁傻\]
    4.  使用的基本的方式
    5.  测试了权限

<table style="margin-left:1.95pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:101.25pt;"> &nbsp; </td> 
 <td style="vertical-align:top;width:111.75pt;"> 同一个类中的成员 </td> 
 <td style="vertical-align:top;width:102.75pt;"> 同一个包中的成员 </td> 
 <td style="vertical-align:top;width:146.25pt;"> 不同包但存在继承的子类 </td> 
 <td style="vertical-align:top;width:70.15pt;"> 全局 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:101.25pt;"> private(私有) </td> 
 <td style="vertical-align:top;width:111.75pt;"> √ </td> 
 <td style="vertical-align:top;width:102.75pt;"> &nbsp; </td> 
 <td style="vertical-align:top;width:146.25pt;"> &nbsp; </td> 
 <td style="vertical-align:top;width:70.15pt;"> &nbsp; </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:101.25pt;"> 默认不写 </td> 
 <td style="vertical-align:top;width:111.75pt;"> √ </td> 
 <td style="vertical-align:top;width:102.75pt;"> √ </td> 
 <td style="vertical-align:top;width:146.25pt;"> &nbsp; </td> 
 <td style="vertical-align:top;width:70.15pt;"> &nbsp; </td> 
 </tr> 
 <tr> 
 <td style="width:101.25pt;"> protected(受保护) </td> 
 <td style="width:111.75pt;"> √ </td> 
 <td style="width:102.75pt;"> √ </td> 
 <td style="width:146.25pt;"> √ </td> 
 <td style="width:70.15pt;"> &nbsp; </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:101.25pt;"> public(公共) </td> 
 <td style="vertical-align:top;width:111.75pt;"> √ </td> 
 <td style="vertical-align:top;width:102.75pt;"> √ </td> 
 <td style="vertical-align:top;width:146.25pt;"> √ </td> 
 <td style="vertical-align:top;width:70.15pt;"> √ </td> 
 </tr> 
 </tbody> 
</table>

### **2.super\[掌握\]** ###

super比较着this学习

1.概念:super在子类的代码中!代表着父类的对象:但是区别于this,

this在代码中,可以打印出地址:但是super不可以打印出地址

2.super的作用

①super可以在子类的代码中调用父类非私有的成员\[普通方法,及字段\]

②可以在子类构造方法的第一句,调用父类的构造方法

③在子类的构造方法第一句,如果没有显示的调用父类的构造方法,会隐式的调用父类的无参数的构造方法!

**注意****:**

1.  1.  1.  1.  使用子类的构造方法一定会调用父类的构造方法
                
                1.  正是因为子类的构造方法,一定会调用父类的构造方法,所以子类才继承到了父类的东西
            2.  JavaBean:要求一个标准的java类一定要提供一个无参数的构造方法!
                
                1.  为什么提供
                    
                    1.  假设定义了一个标准的java类A,里面写了有参数的构造方法,意味着无参数的构造方法没有了
                    2.  假设B类,继承了A类,B类构造方法,没有显示的调用父类的构造方法!意味着会隐式的调用A类的无参数的构造方法,但是!如上i假设,A类中,不存在无参数的构造方法,所以报错,找不到合适的构造器

### **3.多态** ###

1.  1.  基本认识:一种事物的多种形态
    2.  代码Animal a = new Person();//一个父类类型的变量,可以装一个子类类型的对象
    3.  定义来看:编译时与运行时产生了类型不一致,叫做多态
        
        1.  编译过程
        2.  运行过程
    4.  多态的应用示例\[人养狗\]
        
        1.  Animal a = new Person()

1.  1.  1.  多态的方法参数传递
        2.  方法返回值多态形式的体现

### **4.引用数据类型的转换** ###

1.  1.  为什么需要数据类型转换
        
        1.  按照语法,只要是将将父类类型的变量强转成子类类型都可以!但是,万一父类类型变量中,装的不是你想转的类型,类型转换异常
            
            1.  Cat cat = new TomCat();
            2.  Coffee cf = (Coffee)cat;//编译通过,但运行看真实类型,
    2.  数据类型转换的注意事项
        
        1.  转换之前最好判断类型,否则运行出错,代码会退出java虚拟机!意味着代码终止运行\[软件蹦了\]
        2.  判断类型有两种方式
            
            1.  getCalss();
            2.  instanceof\[细节\]

### **5.final** ###

final: 表示最终意思，可以修饰什么内容？类/字段，方法 局部变量  不能修饰构造方法

final修饰类效果：这个类是最终类，太监类，不能继承

final修饰字段，局部变量 效果：这个字段或者局部变量 一旦有值之后，不能再重新赋值

final修饰方法：这个方法不能被覆写

## **Day11面向对象** ##

### **1.单例模式** ###

单例模式特点：

单例模式有以下特点：  
1、单例类只能有一个实例。  
2、单例类必须自己创建自己的唯一实例。  
3、单例类必须给所有其他对象提供这一实例

单例模式实现方式：

1.饿汉模式

饿汉模式：应用当中，不管需不需要对象，都会创建一个对象

有什么问题？

占用内存，消耗资源：希望如果能在需要的时候再创建对象

2. 懒汉模式：当对象需要的时候才创建

①构造方法私有化

②定义一个B类型字段私有化

③提供get方法获取对象，使用static修饰\[\]

④在第一次调用方法的时候才创建对象，以后使用直接引用

⑤判断字段是否为空，为空表示第一次调用该方法，

有什么问题?线程安全问题，有可能会取到不是一个对象（线程加锁后可以控制）

### **2.代码块** ###

\{    \}大括号内的代码就是代码块

方法的代码块\[类中的代码块\]

①按顺序执行

②代码块会有一个控制作用域的作用

③结构化的代码，在方法中，一般结合选择结构，循环结构

才能控制执行流程

类中的代码块

静态代码块

静态加载：字节码文件加载到JVM的时候执行，并且优先于主方法执行！

作用：应用启动的时候，可以初始化一些值，例如单利模式

非静态代码块

会在构造方法中，复制一份非静态的代码块中的代码

作用：复制的代码块会在构造方法中执行

### **3.组合** ###

概念：用一个类的类型的数据，作为其它类的静态属性，迷哦啊书其它类

### **4.枚举：** ###

什么是枚举：

1.解决了什么问题》？

a) 解决了某种数据类型，只有固定的几个值

2.语法(和类的结构很相似)

a) enum Sex\{\}

3.使用

a) 直接方法字段

class \_05EnumDemo \{

public static void main(String\[\] args) \{

System.out.println(Sex.MAN);

System.out.println(Sex.WOMAN);\}

enum Sex\{

MAN("男"),WOMAN("女");

String name;

Sex (String name)\{

this.name = name;

public String toString () \{

return this.name = name;

抽象类：一个类如果使用了abstract修饰，就是抽象类

1.抽象类中可以存在什么东西

字段，普通方法，构造方法，及他类的成员都是可以有的

区别：里面可以有抽象方法

2.抽象类不可以创建对象\[Java规定\]

3.最大的用处是作为模板类，基类，超类\[主要目的就是可以提取公共的部分，专门让别人继承的类

②抽象方法：一个方法，如果被abstract修饰，就是抽象方法

1.没有方法体，可以不用写任何实现

2.抽象方法，只能存在于抽象类或者接口中

3.如果子类也是抽象类，可以不用覆写抽象方法

③抽象类一般作为父类：意味着可以存在多态的形式

### **5.抽象Abstract** ###

①抽象类：一个类如果使用了abstract修饰，就是抽象类

1.抽象类中可以存在什么东西

字段，普通方法，构造方法，及他类的成员都是可以有的

区别：里面可以有抽象方法

2.抽象类不可以创建对象\[Java规定\]

3.最大的用处是作为模板类，基类，超类\[主要目的就是可以提取公共的部分，专门让别人调用的\]

②抽象方法：一个方法，如果被abstract修饰，就是抽象方法

1.没有方法体，可以不用写任何实现

2.抽象方法，只能存在于抽象类或者接口中

3.如果子类也是抽象类，可以不用覆写抽象方法

4.只能存在于接口和抽象类中

5.非抽象类继承到了抽象方法必须覆写

③抽象类一般作为父类：意味着可以存在多态的形式

### **6.接口** ###

接口的作用：怎么用接口

class UsbImpl inmplements USB\{\}//实现了接口

实现类的规范写法：UsbImpl

USB接口中的方法是抽象方法，意味着必须覆写

接口中可以有：

注意事项：

①类支持实现多个接口\[存在继承关系：拥有接口的特性---》干爹\]

②可以继承类的同时实现接口，到那时继承必须写在前面

③接口也是支持多态的写法的

注意：如果实现了多个接口是不支持多态的写法

如果只实现了一个接口可以支持堕胎的写法

继承并且实现了单接口，单接口支持多态的写法，不支持

## **Day12-GUI** ##

### **Eclipse快捷键** ###

基本代码提示： Alt+/

复制代码：Ctrl+Alt+方向键上、下

代码注释：

单行注释：Ctrl+/

多行注释：Ctrl+Shift+/(正斜杠)-------取消多行注释：Ctrl+Shift+\\(反斜杠)

文档注释：Alt+Shift+j

导入包或者删除无用包：Ctrl+Shift+O

删除行:Ctrl+D

向上插入一行：Ctrl+Shi+回车

### **布局模式**  ###

流式 FlowLayout

边框布局BorderLayout

网格布局GridLayout

**自定义布局  **

清空默认布局模式 setLayout(null)

设置组件的大小和坐标 setBounds(int x,int y,int width,int height)

## **Day13GUI套路总结** ##

1.  **GUI编程学习之后的套路总结**

根据学习范围，实现类中的功能，调用相对应的英文方法很有可能就可以得到这个类的其它方法

### **2、组合布局：照着用** ###

流式 FlowLayout 、边框布局BorderLayout、网格布局GridLayout

### **3、实现计算器功能(点击按钮传值)** ###

//导入事件监听机制，监听对象为已创建的按钮和文本框

MyActionListrener MyActionListrener = new MyActionListrener(b1,b2,tf);

//接受监听

b1.addActionListener(MyActionListrener);

### **4、事件监听** ###

就是仿人类的神经系统，当给事件源装上事件监听，就像有了神经反应；

事件监听其实是当事件发生时，主动去调用了一个方法，完成功能

### **5、发现事件监听提供的都是接口** ###

发生一个事件可能的操作很多，尽管Java写了很多的实现类，但是未必能够满足所有事件发生之后，可能处理的情况\[方式\]

一般情况下都是，自己定义实现类，按照自己的方式实现接口，自己也继承了事件监听接口的特性，所以自定义类，也是一个事件监听类\[描述某类事件监听的一个类，具体的对象，就是一个具体的事件监听\]

### **6、事件分类\[什么是事件分类\]** ###

普通事件 ActionEvent ActionLinstener

### **7、事件监听的示例** ###

鼠标事件： 1.操作必须要用到对象再次体现面向对象

2.获得对象的属性，来操作变化

3.一个方法的执行，(如果有参数)必然涉及到参数的传递

键盘事件： 1.匿名内部类

窗口事件： 1.事件源变了

2.事件监听接口，具有事件监听的特性，实现了该接口的类，就是事件监听类，就具有事件监听的特性

3.如果自定义类，去继承了事件监听接口的实现类，也会具有接口的特性，自定义类也会是一个事件监听类

4.自定义类，实现监听事件的共嗯，覆写的接口实现类中的方法！

### **8、菜单的学习** ###

1. 菜单

菜单栏

菜单明细

菜单可以添加菜单明细，但是菜单明细是菜单的父类，所以菜单也可以添加菜单

## **Day14Java中的常用类** ##

一、怎样学习一个类：

1.  类的概念，该类是用来干嘛的
2.  类中的成员有哪些？
    
    1.  字段\[  常量字段   \]
        
        1.  非常量字段\[按照标准的JavaBean\]
    2.  **构造****方法**
        
        1.  什么是构造方法\[基本语法\]
        2.  构造方法的作用

\` 1.构造方法也是一个方法,可以执行功能代码基本的使用new  关键字调用

2.this  super

3.构造方法,创建对象并初始化值\[   意味着的传参数   什么样的什么类型的\]

1.  1.  **普通****方法**\[会学习很多,不用去记具体的方法,但是的知道在哪里查看,怎么用\]
        
        1.  1.  知道方法的概念:可以完成独立的功能的代码块\[方法的结构,该写在什么位置\]
            2.  得学会使用方法:一个方法应该要去看一些什么东西
                
                1.  一个方法的作用是啥
                2.  是否有static修饰:决定**调用****的方式**
                3.  返回值类型:决定了**方法执行的结果**是什么
                4.  看方法名字:决定使用哪个名字的方法
                5.  看参数列表:决定要传哪些参数\[与方法名字决定了调用哪个一个方法\]
                    
                    1.  1.  该参数的意义是什么!\[值的范围…存在一些限制的\]

二、包装类

1、包装类的概念：是将值包装在Integer的对象中

2、包装类创建的方式：一般是通过构造方法传入值，然后才包装进去，但是在java1.4版本后，可以提供自动 装箱和自动拆箱

3、自动拆箱装箱

1）自动装箱：Integer i1 = 10;

2）自动拆箱：System.out.println(i1);

4、享元模式

共享，元素共享【元素：学习数组的时候，数组空间中的值就是元素】

特点： 1、说明：不是所有的类型都会存在元素共享

2、对于Integer是将常用的值缓存起来了，当需要用的时候，直接引用地址就好了【-128~+127】

3、享元模式的好处：常用值直接引用地址，不用反复创建对象，节省系统资源

4、double不会在享元模式缓存值，因为小数太多

三、排错

看到编译通过,说明语法没有问题\[注意:编译只看类型不看值\]

排出错误的方式

1.  删除法:确定错误的位置
2.  打印法:例如默写地方使用值有问题,可以把值打印出来看看是否是自己预想的结果
3.  需要看具体的报错信息
    
    1.  报错的类型可以看:java.lang.NumberFormatException
    2.  看自己写的代码报错的位置
    3.  是否是使用方法有错,就仔细的去看方法的信息
4.  后期适当的时候会教大家用debug方式来调试代码!

*  System

概念： 1、它是一个final修饰的太监类，

2、包含一些有用的类字段和方法。它不能被实例化

1.  跟系统相关的一个类:对外部定义的属性和环境变量的访问，并且提供了操作数组的方法

*  Runtime

概念： 1、每个 Java 应用程序都有一个 Runtime 类实例

自己写的GUI记事本,记事本本质就是一坨代码:运行在JVM中,这些东西都会在JVM中存在一个Runtime实例\[对象\]

2、使应用程序能够与其运行的环境相连接。

存在的Runtime实例,可以使得应用程序,可以与系统环境相关联

3、可以通过 getRuntime 方法获取当前运行时

获得实例的方式!

4、应用程序不能创建自己的 Runtime 类实例

另外：该类只有方法

*  垃圾回收机制

将java代码中无牵引的对象，或意义的对象进行回收，节省内存资源，可通过Runtime类中gc方法实现

*  String、StringBuffer、StringBuilder

1、String

1、常量”ABC”String实例实现\[对象\] 字符串对象不可变

2、字符串不可变的原因

3、字符串正是因为不可变,但是可以共享,缓冲区\[字符串变量,可以指向任意的对象\]

4、常量池\[常量拼接会查看常量池,,变量拼接不会查看常量池,会创建新的对象\]

5、String当中方法的使用

2、StringBuffer

1、线程安全的可变字符序列。

2、对于一个可变的字符序列:涉及的操作:增加  删除  修改  查找

3、面试题：String  StringBuffer  StringBulider的区别

3、StringBuilder

1、它的对象内容是可以被改变的;

2、是线程不安全的

3、版本是 1.5

4、相当于StringBuffer效率更高一点

七、数学相关类Math、BigInteger、BigDecimal

1、Math

概念： 该类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数；

2、BigInteger

概念：该类为一个不可变的任意长度的整数，该类型的整数想要完成运算，必需通过方法

3、BigDecimal

概念：该类表示一个更高精度的小数，相对于double，它的精度可以是任意的，但是小数都是不精准的；

*  随机码Random、ThreadLocalRandom（1.7版本后才有）、UUID

1.  Random：该类的实例用于生成伪随机数，比如经常遇到的验证码，都用于该类的方法
2.  ThreadLocalRandom：属于Random的子类，可用于某个区间的随机数值生成
3.  UUID：一般表示唯一标识符，它表示一个128位的值，可用于公司数据库做数据的标识

*  日期、时间相关类

1.  Date：

概念：表示特定的瞬间，精确到毫秒，可通过建立构造方法获得精确的瞬间

1.  Calendar

概念：抽象类，实现日期和时间字段之间转换\[日历类\]（用处较广）

1.  DateFormat 、SimpleDateFormat 作用类似

1.  把一个Date对象可以转成我们希望的一个结果样式（字符串）
2.  也可以把一个字符串解析为一个Date对象

注意：操作系统固定认为时间是一天86400,不准确,因为存在闰秒

## **Day15异常机制** ##

1.  **StringBuffer/StringBuilding字符序列**

StringBuffer是一个线程安全的字符序列

StringBuilding是一个线程不安全的字符序列但是StringBuilding比StringBuffer执行速度更快

其中的字符飞Final修饰

StringBuffer sb = “”;错误方式

New StringBuffer (“”);正确方式

StringBuilding一样的调用方式

1.  **Math/BigInteger/BigDecimal**

### **BigInteger：支持任意精度的整数，可以精确地表示任意大小的整数值，同时在运算过程中不会丢失任何信息。**  ###

### **BigDecimal：可以精确地表示任意精度的小数，同时在运算过程中不会丢失任何信息** ###

### **3、随机数：** ###

1.  1.  Math
        
        1.  Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

1.  1.  Random
        
        1.  Random rd = new Random();

System.out.println(rd.nextBoolean());

System.out.println(rd.nextInt());

1.  1.  验证码示例ThreadLocalRandom.current()

static String str = "123456789";

int nextInt = ThreadLocalRandom.current().nextInt(0,str.length());

**static** String *str* = "123456789";//相当于存的数据，在当中随机取出

**public** **static** **void** main(String\[\] args) \{

System.***out***.println(*getRandomCode*(4));

**public** **static** **char** getCode()\{

**int** nextInt = ThreadLocalRandom.*current*().nextInt(0,*str*.length());

**return** *str*.charAt(nextInt);

**public** **static** String getRandomCode(**int** num)\{

String code = "";

**for** (**int** i = 0; i < num; i\++) \{

code += *getCode*();

**return** code;

### **4、UUID** ###

表示通用唯一标识符 (UUID) 的类。 UUID 表示一个 128 位的值

这些通用标识符具有不同的变体。此类的方法用于操作 Leach-Salz 变体，不过构造方法允许创建任何 UUID 变体（将在下面进行描述）。

### **5、日期Java.util.Date** ###

1.  DateFormat/SimoleDateFormat

1.  格式化一个日期对象，成为一个字符串形式来表示时间
2.  解析字符串：成为一个日期对象(日后常用)

1.  Calendar获取设置具体的日期字段，年月日时分秒

1.  日历：获取日期字段，设置日期字段：void setTime(Date date);

Date getTime();

### **6、异常** ###

1.  概念
    
    1.  1.  什么是异常
            
            1.  异常不产生结果，代码中止，直接退出虚拟机，异常也是一个类事物
            2.  注意：Error是无法处理的异常

Exception也就是我们经常见到的一些异常情况

1.  分类
    
    1.  1.  除数不能为0

java.lang.ArithmeticException: / by zero

1.  1.  1.  空指针异常

java.lang.NullPointerException

1.  1.  1.  类型强制转换异常：

ClassCastException

1.  1.  1.  数组负下标异常：

NegativeArrayException

1.  1.  1.  数组下标越界异常：

ArrayIndexOutOfBoundsException

1.  1.  1.  违背安全原则异常：

SecturityException

1.  1.  1.  文件已结束异常：

EOFException

1.  1.  1.  文件未找到异常：

FileNotFoundException

1.  1.  1.  字符串转换为数字异常：

NumberFormatException

1.  1.  1.  操作数据库异常：

SQLException

1.  1.  1.  输入输出异常：

IOException

### **7、异常处理方式** ###

1.  自己处理

try \{

//可能会出现异常的语句

\} catch (Exception e) \{

//处理方式

\} finally\{

//最终一定会执行的结果

1.  抛给别人处理

public static void main(String\[\] args) throws Exception\{

### **8、获取异常信息的方式** ###

1.  删除法
2.  打印法

### **9、Finally结构：了解其特点** ###

至少有两种情况下finally语句是不会被执行的：  
（1）try语句没有被执行到，如在try语句之前return就返回了，这样finally语句就不会执行。这也说明了finally语句被执行的必要而非充分条件是：相应的try语句一定被执行到。

（2）在try块|catch块中有System.exit(0);这样的语句。System.exit(0)是终止Java虚拟机JVM的，连JVM都停止了，所有都结束了，当然finally语句也不会被执行到

在try-catch-finally中, 当return遇到finally，return对finally无效，即:

1.在try catch块里return的时候，finally也会被执行。

2.finally里的return语句会把try catch块里的return语句效果给覆盖掉。

结论：return语句并不一定都是函数的出口，执行return时，只是把return后面的值复制了一份到返回值变量里去了。

## **Day16多线程** ##

### **1、线程的概念 :** ###

1.可以看成是一小坨代码,可以独立的获得CPU的资源,独立的执行任务

2.计算机CPU处理任务的最小单位是线程:在一个时间片上高速的切换线程任务

### **2、线程的作用** ###

1.  1.  1.  1.  快播下载电影任务:每一个电影任务都是独立的下载\[  其实每一个下载任务都包装成了一个线程  \]为什么多线程软件可以下载的比较快的原因

**作用****:**

1.  1.  1.  1.  线程将功能独立的包装起来,能够获得CPU的资源独立的执行
            2.  某个功能,封装成一个线程体,获得CPU独立的执行的机会,同时存在多个线程\[多个任务同时在执行\]

### **3、线程的游戏示例** ###

实现线程任务,能够独立的获得CPU执行的机会

独立的功能独立的包装

播放音乐,,,玩游戏\[定义了两个线程类\]

### **4、线程的注意事项** ###

1.  1.  1.  1.  run方法是一个方法,直接调用就是一个普通方法而已
            2.  start启动线程:独立的一个线程任务被启动了.CPU就知道该线程任务的存在会分配资源
            3.  线程任务是独立的,与主线程没有关系

### **5、线程安全的根本原因** ###

1.线程A执行到代码位置1,如果切换到线程B执行再切换会线程A会继续从位置1开始往下执行

### **6、多线程售票示例\[该实例去讲解如何解决线程安全的问题\]** ###

1.  1.  1.  1.  本质功能就一个\[定义了一个线程类\]
            2.  多个窗口,多个线程对象
            3.  分析了线程安全的问题
                
                1.  得出代码是会存在核心业务代码块\[同步的就是核心业务代码块\]
                2.  解决线程安全的问题\[核心业务代码块加锁\]-à同步监听对象\[保证所有的线程访问的是同一个对象\]

### **7、线程的实现方式2** ###

1、implements Runnable 2、extends Thread

### **8、实现和继承的方式区别** ###

1、继承Thread：由于子类重写父类的run(),当调用start()时，直接找子类的run()方法   
2、实现Runnable接口：Thread的构造函数中传入了Runnable引用，成员变量记住它，start()调用Thread中的run()方法时，判断成员变量Runnable的引用是否为空，不为空则在Thread的run()方法中调用Runnable的run()方法。编译看Runnable的run()，运行看子类run()方法。   
继承Thread：（首选这个，如果有了父类就用接口）   
好处是:直接使用Thread类中的方法，代码简单   
弊端是：如果已经有了父类，就不能使用这种方法   
实现Runnable接口：   
好处是：即使自己定义的线程类有了父类也没有关系，因为有了父类也可以实现接口，而接口是可以多实现的   
弊端是：不能直接使用Thread类中的方法，需要先获取到线程对象后，才能得到Thread的方法，代码复杂

### **9、Thread类\[ 线程优先级,线程是否为守护线程  join\]\--à线程对象** ###

通过一个int priority来控制优先级，范围为1-10，其中10最高，默认值为5

设置优先级setPriority()//优先级1-10，超过会报错

获得优先级getPriority()

### **10、线程同步** ###

1.  1.  1.  如何给线程对象命名\[加强了对于面向对象的基本认识\]
        2.  同步线程:目的是为了保护代码, 当有一个线程在访问,其它线程不能访问\[解决线程安全\]
        3.  认识了同步代码块的语法
            
            1.  加强了对于同步监听对象的认识
                
                1.  synchronized (mutex) \{//mutex写在此处的才是同步监听对象
                2.  \}

mutex:存在该位置的才是同步监听对象

1.  1.  1.  1.  同步监听对象可以是任意对象\[保证所有线程访问的是同一个对象\]
            2.  this也可以是同步监听对象,:保证上面两点
            3.  类的字节码对象\[Class \],一个类的字节码对象Class cla = Student.class
                
                1.  对象名.getClass();

5.如下实现同步代码块:都对各种情况下的同步监听对象进行了验证

1.  1.  同步代码块
        
        1.  1.  继承的方式

①mutex:同步监听对象\[保证所有线程访问的是同一个对象\]

②同步监听对象可以是任意的对象

③this也可以作为同步监听对象

最常用的方式:类的Class对象\[字节码对象\],一般用的是当前类的字节码对象

1.对象名.getClass();//获取运行时类

2.类名.class//获取字节码对象

一个类在JVM中只存在一个字节码对象:

1.  1.  1.  1.  实现

①MyThread.class可以:肯定只有一个对象

②this:因为this指代的就是当前对象,而且只创建了一个

③直接在同步监听对象的位置写了一个  new Object();

不行:因为不同的线程访问该代码位置,都会创建一个新的对象

④当前类的字段,写了一个非静态的Object字段:

可以:因为当前对象只创建了一个,所以Object对象也只存在一个

1.  1.  同步方法
        
        1.  1.  继承的方式

同步方法:保证有一个线程在访问方法,其它线程不能访问该方法

synchronized修饰一个方法:该方法就被同步了

同步方法也是有同步监听对象的

有static修饰:默认的同步监听对象是当前类的字节码对象

没有static修饰:默认的同步监听对象是this

不能为了同步,就加static:根据实际的需要

Public static synchronized void  saleOne()\{\}

1.  1.  1.  1.  实现
    2.  锁机制
        
        1.  1.  继承的方式
            2.  实现

### **11、线程通信** ###

建立同步对象，对当前的对象完成休眠等待唤醒其它线程的操作

其实就是同步监听对象

### **12、线程的生命周期** ###

1.  创建：Thread t = new Thread();
2.  就绪：调用了start方法
3.  运行：获得CPU资源，开始执行线程中的代码
4.  死亡：线体执行完毕、异常没有处理好、执行完毕后被垃圾回收机制回收了

注意：线程死了就死了， 不能死而复生

### **13、定时器** ###

定时执行任务

schedule(TimerTask task, Date time)

安排指定延迟后执行任务

想要安排线程任务必须继承TimerTask再去实现线程 schedule方法参数需要

//tm.schedule(mt, 2000);//调用Timer方法schedule   mt指的是对象 2000指毫秒

### **14、面试题两种创建并启动线程的流程和区别** ###

第一种方式：继承Thread类

1.自定义类继承Thread

2.覆盖Thread中的run()方法

3.创建该类的对象，调用start()方法，开启线程并调用run方法

第二种方式：实现Runnable接口

1.定义一个实现Runnable接口的类

2.覆盖run方法

3.创建该类对象，并以该类对象为参数创建Thread类的对象，从而创建了一个线程

4.调用start方法，开启线程并调用run方法

采用继承Thread类方式：  
（1）优点：编写简单，如果需要访问当前线程，无需使用Thread.currentThread()方法，直接使用this，即可获得当前线程。  
（2）缺点：因为线程类已经继承了Thread类，所以不能再继承其他的父类。  
采用实现Runnable接口方式：  
（1）优点：线程类只是实现了Runable接口，还可以继承其他的类。在这种方式下，可以多个线程共享同一个目标对象，所以非常适合多个相

同线程来处理同一份资源的情况，从而可以将CPU代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。  
（2）缺点：编程稍微复杂，如果需要访问当前线程，必须使用Thread.currentThread()方法。

## **Day17** ##

## **Day18集合框架-arr-link** ##

### **1、数据结构** ###

1.  基于数组的容器
2.  基于链表的容器

a)队列

b)堆栈

### **2、集合** ###

1.  ArrayList、LinkedList

方法很多，需要多查API

### **3、遍历集合的方式** ###

普通for循环

Foreach循环

Iterator 迭代器(帮我们循环集合)

### **4、Iterable** ###

实现该接口的集合就可以使用foreach遍历

### **5、面试题：Iterable和Iterator的区别** ###

Iterable接口实现该接口就可以成为foreach的目标

Iterator是list一个方法，通过调用Iterator这个方法可以得到一个迭代器

### **6、皮皮鳝** ###

1. 构建一个窗体InitUI
 
 1. 使用Jframe
2. 构建一个显示面板initWinpanel
 
 1. 使用了Panel
3. 初始化鳝的身体(initSnakeBody)
 
 1. 使用了panel还使用了LinkedList<泛型Panel>来做身体的容器
4. 让鳝动起来 MoveThread（move）
 
 1. 通过构造方法得到Snake对象，通过操作winpanel和显示面板和snakeBody集合容器得到显示在面板上的身体(panel对象)通过操作对象可以改变坐标(去尾加头移动)
5. 添加键盘监听 这里使用了KeyAdapter适配器 使用了匿名内部类
 
 1. 通过键盘监听得到一个KeyCode 37左38上39右40下
 2. 通过传递一个int way到MoveThread里面然后根据way的值来动态修改X，Y的坐标
6. 初始化食物 initFood
 
 1. 通过随机数产生一个XY坐标，让食物的panel随机显示在winpanel上面
 2. 然后再MoveThread里面得到食物panel的坐标和头(last坐标进行判断)

如果相等则删除食物(不去尾)否则去尾加头

## **Day19HashSet-TreeSet** ##

### **1、HashSet** ###

1.  1.  HashSet类特性

不能够添加重复元素

HashSet判断重复元素标准

1、比较两个对象的哈市Code是否相等

2、看两个对象调用equals方法是否为true，如果两个对象的HashCode一致，并且equals结果为true表示相等，重复就无法添加

### **2、TreeSet** ###

### **3、泛型** ###

1、泛型的基本使用

a)创建集合时ArrayList<T>()T代表泛型类型，可以是数据包装类型，也可以是自定义数据类型

b)加入类型后，添加数据只能是该类型

2、注意事项

3、泛型的声明和接口

Student<E>()\{

E name；

E age；

Intface<K>()\{

注意<?>问好为统配符

泛型的上限

List<? Extends Number> list

此处可以传入的list中的类型可以是number或者number的子类类型

泛型的下限

List<? Extends Number> list

此处可以传入的list中的类型可以是number或者number的父类类型

## **Day20-IO流-初识** ##

1.  **创建File**

1、File类基本使用

创建File对象 new File()

File基本方法

exists()抽象路径名表示的文件或目录是否存在。

delete()删除(不走回收站)

isFile()测试此抽象路径名表示的文件是否是一个标准文件。

isDirectory()测试此抽象路径名表示的文件是否是一个目录

**list****(****FilenameFilter**** filter)** 返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录

mkdir()创建此抽象路径名指定的目录。

mkdirs()创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。

1.  **IO流分类**

字节流(文件流)：FileInputStream FileOutputStream

字符流：Reader Writer

注意：字节或字符都需要.colse()关闭流操作

## **Day21-IO流-IntputStrame-OutputStrame** ##

1.  **文件名过滤器**

1.  **FilenameFilter**

//主方法里创建FileNameFilter实现类对象

**public** **static** **void** main(String\[\] args) \{

File file = **new** File("D:/");

String\[\] str = file.list(**new** FileNameFilterTest01());

**for** (String string : str) \{

System.***out***.println(string);

**public** **class** FileNameFilterTest01 **implements** FilenameFilter\{

**public** **boolean** accept(File dir, String name) \{

//覆写方法中，重写规则

**return** name.endsWith("txt");

1.  1.  1.  1.  **FileFilter**

**public** **class** FileFilterTest01 **implements** FileFilter\{

**public** **boolean** accept(File pathname) \{

**return** pathname.getName().endsWith("txt");//相对于FileNameFilter返回值没有String类型，需要先获得文件name字段再多态调用name放回的String类型的endWith字段

**public** **static** **void** main(String\[\] args) \{

File f = **new** File("D:/");

File\[\] fs = f.listFiles(**new** FileFilterTest01());

**for** (File file : fs) \{

System.***out***.println(file);

1.  1.  1.  1.

# **数据库** #

## **1 定义** ##

数据库，可以简单的解释为：**高效的存储和处理数据的介质（主要分为磁盘和内存两种）**。

## **2 分类** ##

根据数据库存储介质的不同，可以将其分为两类，即：关系型数据库（SQL）和非关系型数据库（NoSQL，Not Only SQL）。

## **3 举例** ##

关系型数据库：

*  大型：Oracle、DB2 等；
 *  中型：SQL Server、MySQL 等；
 *  小型：Access 等。

非关系型数据库：

*  Memcached、MongoDB 和 Redis 等。

## **4 区别** ##

关系型数据库：

*  安全，其将数据保存到磁盘之中，基本不可能出现丢失数据的情况；
 *  比较浪费空间，因为其用二维表的形式存储数据。

非关系型数据库：

*  存储数据的效率比较高；
 *  不是特别安全，突然断电时会导致数据丢失。

JavaSE总结

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 JavaSE总结

相关 JavaSE总结

相关 JavaSE复习总结(四)

相关 JavaSE复习总结(二)

相关 JavaSE复习总结(一)

相关 JavaSE复习总结(三)

相关 JavaSE复习总结(五)

相关 JavaSE总结

相关 JavaSE总结

相关 JavaSE基础知识总结