目录
Chapter02 Day05~07-方法-Method-课堂笔记
写在前面：代码之前都写在本地了没有上传完整，有人需要的话私信我再传。后面的内容会新开博文继续更新。
* java中如何书写注释？
1.单行注释：//
2.多行注释：/*55481315
55换房哈弗里看见的减肥*/
3.javadoc注释：
/**
*javadoc注释
*这种注释将会被解析成帮助文档，单独生成
*这种注释将会被解析成帮助文档，单独生成
*这种注释将会被解析成帮助文档，单独生成
*/
* public class 和 Class 的区别
# 一个java源文件当中可以定义多个class
# 一个java源文件当中 public 的 class 不是必须的，可以没有
# 一个 class 会定义生成一个 xxx.class 字节码文件
# 一个java源文件当中定义公开类 public 的 class 只能有一个，且该类名必须和 .java 源文件名称一致
否则编译阶段将报错：
A.java:1: 错误: 类C是公共的, 应在名为 C.java 的文件中声明
public class C{
^
1 个错误
# 每一个class中都可编写main方法，都可以设定程序入口，想执行 A.class中的 main 方法，编译后执行 java A 命令即可。
# 注意：当在命令窗口中执行 java B，那么要求 B.class 中必须有主方法，没有主方法将会出现运行阶段的错误：
“错误: 在类 B 中找不到 main 方法, 请将 main 方法定义为:
public static void main(String[] args)
否则 JavaFX 应用程序类必须扩展javafx.application.Application
* 编译 .java 文件命令： javac JavaFilename.java
运行编译得到的 .class文件命令： java className
若报错： 则修改编译语句为：javac -encoding UTF-8 JavaFilename.java
//cmd中输入native2ascii回车，然后输入中文文字回车，即可得到中文文字对应的unicode编码
标识符
关键字
字面值
变量
数据类型
二进制
字符编码
运算符
控制语句
方法
递归
* 基本数据类型（8种）：
取值范围：
类型描述 数据类型 字节数 默认值 取值范围
字节型 byte 1 0 -2^7~2^7-1 -128 ~ 127
短整型 short 2 0 -2^15~2^15-1 -32768 ~ 32767
整型 int 4 0 -2^31~2^31-1 -2147483648 ~ 2147483647
长整型 long 8 0 -2^63~2^63-1 -9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,8087
单精度
浮点型 float 4 0.0 3.402823e+38 ~ 1.401298e-45
双精度
浮点型 double 8 0.0 1.797693e+308 ~ 4.9000000e-324
字符型 char 2 \u0000 0~2^16-1 0 ~ 65535
布尔型 boolean 1 false true/false
引用数据类型（String） null
short 和 char 表示的种类总数是一样的，只不过char可以表示更大的正整数，因为char没有负数
局部变量必须先声明再赋值才能编译通过且运行成功，成员变量声明之后没有手动赋值也可以编译运行，系统将会默认赋值。例子：见DataTypeTest02.java
* 字符编码：人类定制的人类使用语言————“文字”和计算机还用的语言————“二进制”之间的对照表/字典
(1)常用ASCII码：
'a' --> 97 【01100001】
'A' --> 65
'0' --> 48
(2)国标码（国际标准组织制定的编码，只支持西欧文字）————IOS 8859-1（latin-1）
(3)支持简体中文的编码方式：GB2312 < GBK < GB18030 (字库容量)；
(4)支持繁体中文的编码方式：big5（大五码）
(5)后来出现的一种编码方式统一全球所有文字，容量大————Unicode编码(java采用的编码方式)
unicode编码多种实现方式：
UTF-8
UTF-16
UTF-32
java采用的编码方式是unicode编码，所以标识符可以用中文。
eg：
class 学生
现在实际开发中，一般采用 UTF-8 编码较多。
* 总结第二章到目前为止所学内容
1 标识符
2 关键字
3 字面值
4 变量
5 数据类型
* 运算符
- 算术运算符
- 关系运算符
- 逻辑运算符
- 字符串连接运算符
- 三元运算符
Day04-课堂笔记
一、运算符【剩下的运算符】
1、赋值运算符
2、字符串连接运算符
3、三目运算符/三元运算符/条件运算符
1、java中的赋值运算符：
1.1 种类
1）基本的赋值运算符 =
2）扩展的赋值运算符 += -= *= /= %=
1.2 特点：先执行等号右边的表达式，再将执行结果赋值给左边的变量
1.3 扩展类的赋值运算符不改变变量类型
eg：注意以下代码：
byte i = 10;
i += 5; 等同于： i = (byte)(i + 5);
int k = 10;
k += 5; 等同于： k = (int)(k + 5);
long x = 10L;
int y = 20;
y += x; 等同于： y = (int)(y + x);
2、字符串连接运算符：关于java中的“+”运算符：
2.1、+ 运算符在java语言中的两个作用：
* 加法运算，求和
* 字符串的连接运算
2.2、当“+”两边都是数字：一定做加法运算
2.3、当“+”两天只要存在字符串：一定进行字符串连接运算，且连接运算后的结果仍为字符串类型
数字 + 数字 ——> 数字 【求和】
数字 + “字符串” ——> “字符串” 【字符串连接】
2.4、一个表达式中可出现多个“+”，无括号时自左向右依次运算
3、三元运算符/三目运算符/条件运算符
3.1 语法规则： 布尔表达式 ? 表达式1 : 表达式2
3.2 三元运算符的执行原理：布尔表达式结果为true，选择表达式1为布尔表达式的执行结果；false则选择表达式2为执行结果
boolean sex = false;
char c = sex ? '男' : '女';
String s = sex ? "男生" : "女生";
* 控制语句
java控制语句7种：
控制选择结构语句：if、if else、switch
控制循环结构语句：for、while、do while
改变控制语句顺序：break、continue
* 向控制台输出（从内存到控制台） System.out.println();
接收键盘输入（从键盘到内存） 代码如下：
第一步：java.util.Scanner s = new java.util.Scanner(System.in);
第二步：String str = s.next(); 或 int num = s.nextInt();
具体示例可见：KeyInputTest.java文件
//cmd中输入native2ascii回车，然后输入中文文字回车，即可得到中文文字对应的unicode编码
一、方法 - Method
1、方法的本质:一段代码片段,可完成某个特定的功能,能被重复使用.
2、方法在C语言中被称作函数Function
3、方法定义在类体中,一个类当中可定义多个方法,方法编写位置无先后顺序,随意
4、方法的语法结构:
{修饰符列表} 返回值类型 方法名(形式参数列表){
方法体;
}
5、对以上的语法结构进行解释说明
* 关于修饰符列表:
1) 可选项，非必须
2) 目前统一写成: public static [以后讲]
3) 方法的修饰符列表当中"有static关键字"的话，调用方法？
类名.方法名（实际参列表）;
* 返回值类型:
1) 定义:一个方法是可以完成某个特定功能的，这个功能结束之后大多数都是需要返回最终执行结果的
2) 返回值类型:返回值是一个具体存在的效据，数据都是有类型的，此处需要指定的是返回值的具体类型
3) 可指定类型:Java任意一种类型都可以，包括基本数据类型和所有的引用数据类型(byte,short,long,int,boolean,float,double,char,String,void)
4) 方法也可以不返回任何数据,返回值类型必须写:void,则方法体不可出现 return 值; 语句,可写 return; 语句
5) 返回值类型不是void,表示方法执行结束必须返回具体数值,否则编译器将报错,使用 return 数值; 语句返回值
6) 返回值类型必须和return后数值类型一致,否则编译器报错
7) 只要带有return关键字的语句执行,其所在方法结束。注:不是JVM结束，是return所在方法结束
* 方法名:
1) 只要是合法的标识符就行
2) 方法名最好见名知意
3) 方法名最好是动词
4) 方法名首字母要求小写，后面每个单词首字母大写(驼峰命名)
* 形式参数列表(形参):
1) 形参是局部变量:int a; double b; float c; string s;
2) 形参的个数可以是:0-N个
3) 多个形参之间用逗号隔开
4) 形参中起决定性作用的是形参的数据类型，形参的名字就是局部变量的名字
5) 方法在调用的时候，实际给这个方法传递的真实数据被称为:实际参数(实参)
6) 实参列表和形参列表必须满足: 数量相同、类型对应相同
eg:
方法定义
public static int sum(int 变量名,int 合法的标识符就行){
}
方法调用
sum("abc","def") //编译器报错
sum(10,20)
* 方法体必须由大括号括起来，方法体当中的代码有顺序，自上而下依次执行,方法体中每一个java语句以;“结尾.
6、方法调用：
方法的修饰符列表当中有static关键字，完整的调用方式：类名.方法名(实参列表)
但有时"类名."可以省略,什么情况下可省?——同类可省:调用程序和被调用方法在同一个类中,则"类名."可省略不写
省略"类名."会默认从当前类中找方法。
建议在一个java源文件中只定义一个class，比较清晰，这里只是为了讲课方便而编写多个class，请勿模仿！
7、方法在执行过程当中,在JVM中的内存是如何分配,如何变化的?
1)方法只定义,不调用,是不会执行的,在JVM中也不会给该方法分配"运行所属"的内存空间,调用时才会分配内存空间
2)在JVM内存划分上有这三块主要内存空间:
* 方法区内存
* 堆内存
* 栈内存
3)关于栈数据结构:
* 栈:stack,一种数据结构(反映的是数据的存储形态)
* 作为程序员需要提前精通:数据结构 + 算法
* 常见的数据结构:数组、队列、栈、链表、二叉树、哈希表、散列表
* java程序员可在不精通数据结构和算法的前提下进行java开发,因为java有一套庞大的类库支撑
4)方法代码片段存在哪里?方法执行时候,执行过程的内存在哪里分配?
* 方法代码片段属于 .class 字节码文件的一部分,字节码文件在类加载的时候,将其放到了方法区中.
所以JVM中三块内存空间中方法区内存最先有数据,存放了代码片段(小说书本文字)
* 代码片段虽然在方法区当中只有一份,但是可以被重复调用
每一次调用此方法都需要给该方法分配独立活动场所,在栈内存中分配(小说情节实际发生地点)
栈内存中分配方法运行的所属内存空间
5)方法在调用瞬间,会给该方法分配内存空间,会在栈中发生压栈动作 push;(给方法分配内存)
方法结束之后,给该方法分配的内存空间全部释放,此时发生弹栈动作 pop.(释放该方法的内存空间)
6)局部变量在"方法体"中声明,运行阶段内存在栈中分配.
8、Day07 - 课堂笔记
* 方法执行过程中的内存分配
1)在EditPlus当中,红色字体表示一个类的名字,且此类为JAVASE中自带的
D:\Java\jdk1.8.0_121\jre\lib\rt.jar\java\lang中
例如:System.class/String.class/Math.class......
只要是类名就一定是标识符
2)重点:方法调用时,只要涉及到参数传递的问题,实际上是变量中保存的那个"值"传过去了
3)方法执行时遵循自上而下的顺序依次执行
* 方法的重载机制
优点:
1)程序员调用方法方便,随调用不同方法,但感觉在调用同一方法,无序记忆更多方法名
2)功能相似时方法名不同,功能不同方法名不要相同,不要重载
重载:
1)方法重载又称为:overload
2)合适考虑使用方法重载?
* 功能相似时,尽可能让方法名相同; 但功能不相似时,尽可能让方法名不同
3)什么条件满足之后构成了方法重载?
* 在同一类中
* 方法名相同
* 参数列表不同: 数量不同/顺序不同/类型不同
4)方法重载和什么有关,和什么无关?
* 和参数列表类型有关,和返回值类型无关
* 和修饰符列表无关
* 方法的递归调用
1)什么是递归? ----方法自身调用自身
a(){
a();
}
2)递归很耗费内存,可不使用时尽量不要用
3)递归永不结束时候程序报错:java.lang.StackOverflowError
栈内存溢出错误
错误发生无法挽回,只有JVM停止工作一个结果.
4)故递归必须有结束条件,若无则会发生栈内存溢出错误
5)递归即使有结束条件且结束条件正确,也可能会发生栈内存溢出错误
Day05-课堂笔记
一、控制语句 - switch
1、switch 语句属于选择结构、也是分支语句
2、switch 语句语法结构（jdk6只支持int，7开始支持String）
switch(int 或 String 类型的变量/字面值){
case int 或 String 类型的变量/字面值：
java语句;
.....
break;
case int 或 String 类型的变量/字面值：
java语句;
.....
break;
case int 或 String 类型的变量/字面值：
java语句;
.....
break;
......
default :
java语句;
......
}
3、switch 语句执行原理：
switch小括号当中的数据和case后面的“数据”进行一一匹配，匹配成功的分支执行，自上而下依次匹配。
4、匹配成功的分支执行，分支中有 break; 时，整个 switch 语句中止。
5、匹配成功的分支执行，但当分支中无 break; 时，则下面的语句不进行匹配，直接执行下一分支；
这是【case 穿透现象】。
6、所有分支都没有匹配成功，当有 default 语句时，执行 default 分支中语句。
7、switch 后面和 case 后面只能是 int 或 String 类型的变量/字面值，不能探测其他类型
当然 byte、short、char 也可以直接写到 switch 和 case 后面，因可进行自动类型转换成int
JDK6的 switch 和 case 后面只能探测 int 类型
JDK7之后包括7版本在内，引入新特性，switch 和 case 后面可探测 int 或 String 类型数据
8、case 可以合并：
int i = 10;
switch(i){
case 1: case 2: case 3: case 10:
System.out.println("Test Code!");
}
二、控制语句 - for
1、语法结构:
for(初始化语句1; 布尔判断语句2; 更新语句4){
java语句3
}
其中：for后面三个语句都不是必需的，但是两个两个分号却是，故分号不能丢。
2、执行顺序：1 2 3 4 2 3 4 2 3 4 2 3 4 2 ……/1 2
三、循环语句 - while
1、语法结构:
while(布尔表达式1){
循环体2;
}
(布尔表达式1为true则执行循环体2,为false则循环结束)
2、执行顺序: 1/1 2 1 2 1 2 1 2 1 2 1 2 ......1
3、循环体执行次数: 0次 ~ N次
四、循环语句 - do...while
1、语法结构:
do{
循环体1;
}while(布尔表达式2);
(布尔表达式2为true则执行循环体1,为false则循环结束)
2、执行次数: 1次 ~ N次
3、执行顺序: 1 2/1 2 1 2 1 2 1 2 1 2 1 2 ......2
五、中断/终止语句 - break
1、break; / break 循环名称;
2、使用环境:
1)switch 语句中,终止该语句的执行
2)循环语句(for,while,do...while)当中,用来跳出/终止循环的执行,可提高程序执行效率
六、继续语句 - continue
1、continue; / continue 循环名称;
2、含义:继续/go on/下一个
3、break 和 continue 的区别：
break 表示循环不执行了，跳出循环，终止循环
continue 表示终止当前“本次”循环，直接进入下一次循环继续执行
Chapter03 面向对象 Java语言的核心机制
面向过程和面向对象的区别
面向对象的三大特征
类和对象的概念
类的定义【从这里开始编写代码】
一、采用面向对象的方式开发一个软件，生命周期包含：
1、面向对象的分析：OOA
2、面向对象的设计：OOD
3、面向对象的编程：OOP
整个生命周期中贯穿着面向对象方式OO
二、 面向对象的三大特征
1、封装
2、继承
3、多态
三、类的概念
类不存在于现实世界，是一个模板、概念，是人类大脑思考抽象的结果。
类代表一类食事物
在现实世界中，对象A和对象B之间具有共同特征，进行抽象总结出一个模板，此模板即为类
一个类主要描述 状态 + 动作
状态 --> 一个类的属性
动作 --> 一个类的方法
类{
属性；//描述对象的状态信息
方法；//描述对象的动作信息
}
四、对象的概念
对象是实际存在的个体，现实世界中实际存在
对象和对象之间有共同的特征，但是具体到对象之后可能有数据的差异
五、类的定义【从这里开始编写代码】
语法结构：
[修饰符列表] class 类名{
}
1、属性通常采用成员变量的方式来定义
2、方法描述的是对象的动作信息
六、Java语言当中包括的两种数据类型
1、基本的数据类型：byte、short、int、long、float、double、boolean、char
2、引用数据类型：String、System（SUN提供的）、User、Product、Student、Customer（程序员自定义的）
Java中的class都属于引用数据类型
七、对象的创建和使用
1、创建（实例化对象）语法： new 类名();
2、new运算符作用：创建对象，在JVM堆内存中开辟新内存空间
3、方法区内存：类加载时class字节码片段被加载到该内存空间中
栈内存（局部变量）：方法代码片段执行时，会给该方法分配内存空间，在栈内存中压栈
堆内存：new 的对象在堆内存中存储
4、局部变量：存储位置：栈内存、书写位置：类体的方法内
成员变量：存储位置：不确定、书写位置：类体中方法体外
成员变量 中的 实例变量：在 堆内存 的java对象内部存储
实例变量是一个对象一份，100个对象有100份
5、对象和引用的区别联系：
对象：new 运算符在堆内存中开辟的内存空间称为对象；
引用：引用是一个变量，只不过这个变量中保存了另一个Java对象的内存地址
6、关于引用：
Java语言中，程序员不能直接操作堆内存，Java没有指针，不像C语言；
Java语言中，程序员只能通过“引用”去访问堆内存当中对象内部的实例变量
7、访问实例变量的语法格式：
读取数据：引用.变量名;
修改数据：引用.变量名 = 值;
八、Java虚拟机主要包括三块内存空间：方法区内存、堆内存、栈内存
1、堆内存和方法区内存各有一个；栈内存一个线程对应一个栈内存；
2、方法调用时，该方法所需内存空间在栈内存中分配，称为压栈，方法执行结束后，该方法所属内存空间释放，称为弹栈
3、栈中主要存储的是方法体中的局部变量
4、方法的代码片段以及整个类的代码片段都被存储到方法区内存当中，在类加载时，这些代码片段会载入
5、在程序执行过程中，使用new运算符创建的Java对象，存储在堆内存当中，对象内部有实例变量，所以实例变量存储在堆内存当中
6、变量分类：
局部变量【方法体中声明】：存储在栈内存
成员变量【方法体外类体中声明】
1）实例变量【前面修饰符无static】：存储在堆内存
2）静态变量【前面修饰符有static】：存储在方法区内存中
7、三块内存中：
变化最频繁的：栈内存
最先有数据的：方法区内存
垃圾回收器主要针对的：堆内存
8、垃圾回收器【自动回收机制/GC机制】何时会考虑将某个Java对象的内存回收呢？
没有更多的引用指向堆内存中的Java对象时，此对象无法被访问（因为访问对象只能通过引用方式），故此对象会被回收。
九、空指针报错
空引用访问"实例"相关的数据一定会出现空指针异常 java.lang.NullPointerException
如以下程序：
Customer c = new Customer();
System.out.println(c.id); //0
c = null;
System.out.println(c.id); //运行报错空指针
封装
一、好处：
1、封装后，对于那个事物来说，看不到复杂一面，只看到简单一面
复杂性封装对外提供简单的操作入口。如：照相机/电视机内部实现原理复杂，操作使用却非常方便快捷。
2、封装后才会形成真正的“独立体”，真正的“对象”。
3、封装就意味着以后的程序可以重复使用，且适用性强，可在任意场合适用。
4、提高安全性，安全级别高。
二、步骤：
1、所有属性私有化，使用 private 关键字修饰，修饰的数据只能在本类中访问
2、对外提供简单的操作入口，外部程序想要访问私有属性必须通过这些简单入口
- 对外提供两个公开的方法，分别是set方法（修改属性）和get方法（读取属性）
- 一般都要在set方法中加安全控制，因为要修改数据
3、set方法的命名规范：public void set+属性名首字母大写(参数)
public void setAge(int a){
age = a;
}
4、get方法的命名规范：public void set+属性名首字母大写()
public int getAge(){
return age;
}
5、背诵内容：
1）setter and getter 方法没有static关键字
2）有static关键字修饰的方法怎么调用：类名.方法名(实参);
3）无static关键字修饰的方法怎么调用：引用.方法名(实参);
构造方法：
1、构造方法又被称为构造函数/构造器/Constructor
2、语法结构：
[修饰符列表] 构造方法名(形式参数列表){
构造方法体;
}
3、回顾普通方法的语法结构:
[修饰符列表] 返回值类型 方法名(形式参数列表){
方法体;
}
4、对于构造函数来说,"返回值类型"不需要指定,并且也不能写void(写了就是普通方法)
5、构造方法的方法名必须和类名保持一致
6、构造方法的作用: 1)通过构造方法的调用,可以创建对象 2)创建对象的同时,初始化实例变量的内存空间
7、普通方法调用:方法修饰符中有static时:类名.方法名(实参列表)、无static时:引用.方法名
构造方法调用: new 构造方法名(实参列表)
8、每个构造方法执行结束都有返回值,但这个return语句不用写,返回值类型是构造方法所在类的类型
9、当一个类中没有构造任何方法,系统默认给该类提供一无参的构造方法,为缺省构造器
10、当一个类由用户将构造方法定义出来了,那么系统将不再提供缺省构造器,建议开发中手动为当前类提供无参数构造方法
11、构造方法显示可以重载,在一个类中编写多个不同参数列表的构造方法,这些构造方法可以重载
对象和引用：
1、对象：目前在使用new运算符在堆内存中开辟的内存空间称为对象
2、引用：保存了内存地址，指向堆内存中的对象。
3、引用是一个变量，不一定是局部变量，还可能是成员变量（husband类中有Wife类的变量w）
4、所有访问实例相关的数据，都需要通过“引用.”的方式访问，因为只有通过引用才能找到对象
5、只有一个空的引用 访问对象的实例相关的数据会出现空指针异常
class Student{
Computer com; //com是一个引用【实例变量】
public static void doSome(){
Computer c; //c是一个引用【局部变量】
}
}
Java语言中方法调用时涉及到的参数传递问题：
参数传递实际上传递的是变量中保存的具体值，而不是变量本身！
eg：
int i = 5;
int j = i; //i传递给j,实际上只是把i变量中的5传给j了,j实际上是一块全新的内存空间
User u1 = new User(); //假设 u1 = 0x1234
u1.name = "Lily";
User u2 = u1; //u1传递给u2,实际上是将0x1234这个对象的地址值赋给u2了.
u2.name = "Clara";
//u1和u2实际是两个不同的局部变量,但此时这两个变量指向堆内存中同一个java对象
System.out.println(u1.name); //结果为Clara
Day10：this关键字
1、this是一个关键字，翻译为：这个
2、this是一个引用、一个变量，this变量汇总保存了内存地址指向自身，this存储在JVM堆内存Java对象内部
3、创建100个Java对象，每个对象都有this（100个不同的this）
4、this可以出现在“实例方法”中，指向当前正在执行这个动作的对象
5、this在多数情况下都是可以省略不写的
6、this不能使用在带有static的方法当中
1）带有static的方法中不能“直接”访问实例变量和实例方法，因为它们都需要对象的存在
2）而static的方法当中当前对象不存在，也就是没有this，自然也就无法访问当前对象的实例变量和实例方法
7、this可以用在哪里：
1）可以使用在实例方法中，代表当前对象【语法格式：this.】
2）可以使用在构造方法中，通过当前的调用方法调用其他的构造方法【语法格式：this(实参)】
重点【记忆】：this()这种语法只能出现在构造函数的第一行
eg：
public Customer(String name,int age) {
this.name = name;
this.age = age;
}
public Customer(){
this("初始化姓名",-1);
}
8、实例相关的数据包括：
实例变量【对象需要存在】
实例方法【对象需要存在】
9、带有static的方法,其实既可以采用类名的方式访问,也可以采用引用.的方式访问；
但是即使采用引用的方式去访问,实际上执行的时候和引用指向的对象也无关；
带有static的方式还是建议使用"类名."的方式访问；
所以计算使用空引用访问带有static的方法，也不会产生空指针异常的报错。
Test t = new Test();
//引用是空
t = null;
t.doSome(); //这里不会报错空指针异常
Day10：static静态变量
1、static：静态的
static修饰的变量：静态变量
static修饰的方法：静态方法
所有static修饰的元素都是静态的，都可以使用“类名.”（推荐）和“引用.”的方式访问
所有static修饰的元素都是类级别的特征，和对象无关。
2、静态变量：
对所有对象一个属性都一样,属性值相同，这种特征属于类级别的特征,可以提升为整个模板的特征,变量前加static关键字修饰
静态变量在类加载的时候初始化,不需要创建对象,内存就开辟了。（实例变量在构造方法执行的时候初始化）
静态变量存储在方法区内存中。
（局部变量存储在栈内存中，
实例变量存储在堆内存的java对象内部）
3、静态代码块
可以使用static关键字定义静态代码块
1）语法格式：
static{
java语句;
}
2）静态代码块在类加载时执行，并且只执行一次
3）静态代码块在一个类中可以编写多个，并且遵循自上而下的顺序依次执行
4）静态代码快的作用？怎么用？用在哪儿？什么时候用？
和具体需求有关，如项目中要求在类加载的时刻/时机，执行代码，完整日志的记录，那么这段记录日志的代码就可以编写到静态代码块中。
静态代码快是java为程序员准备的一个特殊的时刻——类加载时刻，若希望在此刻执行一段特殊的程序，这段程序可以直接放到静态代码块当中。
4、实例代码块/语句块(了解内容即可,使用的非常少)
1)实例代码块可以编写多个,也是遵循自上而下的顺序依次执行
2)实例代码块在构造方法执行之前执行,构造方法执行一次,实例代码块对应执行一次
3)实例代码块也是java语言为程序员准备的一个特殊时机——对象初始化时机
5、静态方法：方法什么时候定义为静态的?
方法描述的是动作,当所有的对象执行这个动作的时候,最终产生影响是一样的,那么这个动作不再属于某一对象,
可以将这个动作提升为类级别的动作,模板级别的动作。
静态方法中无法直接访问实例变量和实例方法。
大多数方法都定义为实例方法，一般一个行为或者一个动作在发生的时候，都需要对象的参与。
但也有例外，如：大多数“工具类”方法都是静态方法，因为工具类就是方便编程，为方便方法的调用，自然不需要new对象是最好的。
6、实例变量：
构造方法执行时初始化，存在堆内存的java对象内部，“引用.”方式访问。
总结:
class 类{
静态代码块;
实例代码块;
静态变量;
实例变量;
构造方法;
实例方法;
}
7、带有static的方法,其实既可以采用类名的方式访问,也可以采用引用.的方式访问；
但是即使采用引用的方式去访问,实际上执行的时候和引用指向的对象也无关；
带有static的方式还是建议使用"类名."的方式访问；
所以计算使用空引用访问带有static的方法，也不会产生空指针异常的报错。
Test t = new Test();
//引用是空
t = null;
t.doSome(); //这里不会报错空指针异常
day10-类的继承笔记
1、继承是面向对象三大特征之一（封装、继承、多态）
2、继承基本的作用：代码复用，但继承最重要的作用是：有了继承才有了以后“方法的覆盖”和“多态机制”。（面试可能问，后面作用更重要）
3、继承语法格式：
【修饰符列表】 class 类名 extends 父类名{
类体 = 属性 + 方法;
}
4、java语言中的继承只支持单继承，一个类不能同时继承很多类，只能继承一个类。（C++中支持多继承）
5、关于继承的一些术语：
B类继承A类，其中：
A类称为：父类、基类、超类、superclass
B类称为：子类、派生类、subclass
6、java中子类继承父类都继承哪些数据呢？
私有的不支持继承
构造方法不支持继承
其他数据都可以被继承
7、虽然java语言中只支持单继承，但是一个类也可以间接继承其他类，如：
C extends B{
}
B extends A{
}
A extend T{
}
C类直接继承 B类，间接继承 A类、T类。
8、java语言中假设一个类没有显示的继承任何类，该类默认继承JavaSE库中提供的java.lang.Object类（老祖宗）。
java语言中任何一个类中都有Object类的特征。
public class Account {
private String actno;
private double balance; //余额
public Account() {
super();
}
public Account(String actno, double balance) {
this.actno = actno;
this.balance = balance;
}
public String getActno() {
return actno;
}
public void setActno(String actno) {
this.actno = actno;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
}
//信用卡类
public class CreditAccount extends Account {
private String actno;
private double balance;
private double credit;
public CreditAccount() {
}
public double getCredit() {
return credit;
}
public void setCredit(double credit) {
this.credit = credit;
}
}
/*
继承语法格式：
【修饰符列表】 class 类名 extends 父类名{
类体 = 属性 + 方法;
}
*/
public class ExtendsTest {
public static void main(String[] args){
ExtendsTest et = new ExtendsTest();
String s = et.toString(); //等号右边:引用.实例方法,说明可以调用toString方法，ExtendsTest类中继承的JavaSE库中提供的java.lang.Object类中的方法
System.out.println(s); //ExtendsTest@1540e19d
CreditAccount act = new CreditAccount();
act.setActno("act-001");
act.setBalance(-65354.8);
act.setCredit(0.99);
System.out.println(act.getActno() + "," + act.getBalance() + "," + act.getCredit());
}
}
public class ExtendsTest2 {
public static void main(String[] args) {
C c = new C();
c.doSome(); //这里调用的方法是从B类中继承来的doSome()方法
}
class A{
public void doSome(){
System.out.println("do Some!");
}
}
class B extends A{
// public void doSome(){
// System.out.println("~~~do Some!~~~");
// }
}
class C extends B{
}
}
9、方法的重载
1）方法重载又称为Overload
2）使用时间：在同一个类中，方法完成功能相似，建议方法名相同，方便程序员编程，就像在调用一个方法，代码没变。
3）什么条件满足之后构成方法重载？
在同一个类当中
方法名相同
参数列表不同：类型、顺序、个数
4）方法重载和什么无关？
和方法的返回值类型无关
和方法的修饰符列表无关
10、方法的覆盖（方法的重写）
1）方法覆盖/重写：英语单词——Override【官方的】/OverWrite
2）什么时候使用方法重写？——当父类中的方法已经无法满足子类中的业务需求，子类需要对继承的父类的方法进行方法重写/覆盖。
3）代码满足什么条件之后发生方法重写？
方法重写发生在具有继承关系的父子类之间
方法重写的时候：方法名相同，返回值类型相同，形参列表相同，即public void move(){}中的 void move() 都不能变化
方法重写的时候：访问权限不能更低，只能更高（只能private->public，不能public->private）
方法重写的时候：抛出异常不能更多，可以更少 【回头讲异常】
4）建议方法重写的时候尽量复制粘贴/工具生成，不要编写，容易出错，导致没有产生覆盖
5）注意：
私有方法不能继承，所以不能覆盖
构造方法不能继承，所以不能覆盖
静态方法不存在覆盖。【讲完多态后解释】
覆盖只针对方法，不针对属性
public class Animal {
// public void move() throws Exception{
public void move(){
System.out.println("动物在移动");
}
}
//飞禽类
public class Bird extends Animal{
public void move(){
System.out.println("鸟儿在飞翔");
}
}
public class Cat extends Animal{
public void move(){
System.out.println("猫在走猫步");
}
}
public class YingWu extends Bird{
@Override
public void move() {
// super.move();
System.out.println("鹦鹉飞不起来!");
}
}
public class OverrideTest01 {
public static void main(String[] args) {
Animal a = new Animal();
a.move();
Cat c = new Cat();
c.move();
Bird b = new Bird();
b.move();
YingWu y = new YingWu();
y.move();
}
}