java笔记，传智播客1-10，极客，java核心卷
Java常见误解
1）java是HTML的扩展
Java是一种程序设计语言，HTML是一种描述网页结构的方式，处理用于放置java applet的HTML扩展之外，两者没有任何共同之处
2）使用XML,就不需要java
java是一种程序设计语言，XML是一种描述数据的方式，可以使用任何一种程序设计语言处理XML数据，而java API对处理XML提供了很好的支持。此外，很多重要的第三方XML工具采用java编写。
3）Java是一种非常容易学习的程序设计语言
功能强大的语言大部分都不太容易学习，首先，必须将编写的玩具式程序的轻松和开发实际项目的很难区分，
4）Java将成为适用于所有平台的通用性编程性语言
理论上讲，java完全可以适用于所有平台，然而，有很多在桌面计算机已经工作良好的应用程序，在其他设备或浏览器中或许不能正常工作。同时，在编写程序是，利用率相应处理器速度和本地的用户接口库，而且他们已经被一只到所有重要的平台上，这类应用程序包括：字处理程序、图片编辑器以及web浏览器。他们通常是C,C++编写的，采用java语言重新编写似乎对最终用户不会带来什么特别的。
5）Java只不过是另外一种程序设计语言
java是一种很好的程序设计语言，程序设计语言的成功更多取决于支撑系统能力，而不是优美的语法，人们主要关注：是否提供了易于实现某些功能的易用、便捷和标准的库？是否有强大的程序设计能力与调试工具？语言和工具是否能够与计算机的其他基础结构整合在一起？java的成功源于其类库能够让人们轻松的完成原本有一定难度的事情，例如：联网和多线程。Java减少了指针错误，因此使用java编程的效率更高。
6）C#出现，java已经过时了
C#借鉴了java的许多思想，例如：清晰的语言结构、虚拟机和垃圾收集器。无论怎样C#还是沿用了一些好的特性，其中最重要的是安全性和平台无关性
7）Java有专利，应避免使用
Sun Microsystems负责java的许可发放给销售者以及最终用户，尽管Sun公司通过java Community Process最终控制着java，但他们同时与许多其他公司联手一起进行语言修订版的开发以及新类库的设计。虚拟机和类库的源代码都可以免费获取，但是，只能查阅、不能修稿、也不能再发布，至此，java已经“关闭源代码，但运转良好”，
这种情况在07年发生了戏剧性改变，Sun声称java未来的版本将在General Public License下可用，Linux使用的是同一个开放源代码许可。
8）Java是解释性的，因此对于关键的应用程序速度太慢了
早期的java是解释性的，现在除了像手机这样的微型平台之外，Java虚拟机使用了即时编译器，因此采用java编写的“热点”代码其运行速度与C++相差无几
Java有一些java没有的额外开销，虚拟机的启动时间要慢一点，并且java GUI要比本地的GUI慢一些，这是因为他们采用了与平台无关的绘图方式
9）所有java程序都在网页中运行
所有的java applet 都是在网页浏览器中运行，这也恰恰是applet的定义，即一种在网页中运行的java程序，然而，大多数java程序是运行在web浏览器之外的独立应用程序，实际上，很多java都在web服务器上运行并生成用于网页的代码
10）Java程序有主要的安全风险
早期的java，有过安全系统失效的报道。大多数安全问题都存在于java特定浏览器中，研究人员将这视为一项挑战，即努力找出java的漏洞，对applet安全模型的强度和复杂度发起挑战，随后，人们很快就解决了引发问题的所有技术因素，据我们所知，任何实用系统都有安全危机，想象一下，有数百万病毒攻击者Windows的可执行程序和Word宏，这给系统造成了巨大的危害，但却很少有人批评，攻击平台的脆弱，
11）javaScript是java的简易版
使用java可以用价值avaScript是一种在网页中使用的脚本语言，由Netscape发明，JavaScript语法类似于java,除此之外，两者无任何联系，JavaScript的一个子集已经标准化为ECMA-262,与java applet相比，JavaScript更紧密地于浏览器集成在一起，特别是JavaScript程序可以修改正在显示的文档，而applet只能在优先区域内控制外观。
12）500美元的internet设备取代电脑
Java程序错误分为编译期语法错误、运行期异常错误和运行期逻辑错误
编译期语法错误Ecplise的帮助方便定位和修改
运行期异常，系统会提示错误的类型和出错位置
逻辑错误，程序结果与预期结果不符
Java，Debug调试
调试时查找、解决软件中逻辑错误代码bug的重要手段，使软件开发中必不可少的环节
调试也是学习、研究其他人编写代码的一个很好的手段
Eclipse提供了强大的代码调试功能--Debug，通过Debug视图能快速定位代码中的逻辑错误，提高软件开发效率
断点是在源代码的可执行部分指定行设置一个标志，在调试运作方式下，程序运行到该断点标志处会自动暂停，等待下一步操作
通过设置断点可以快速执行断点之前的代码，然后再断点处暂停，这是可以换单个命令运行的方式来运行程序，查找程序中的逻辑错误断点的设置是程序员怀疑错误代码的附近
Day02
关键字：被java赋予特定含义的单词
特点：组成关键字的单词字母全部小写
注意事项：goto和const作为保留字存在，目前并不适用。关键字在编辑工具中有特殊颜色标记
标识符：给类、接口、方法、变量等起名字是所用的字符序列
组成规则：字母、数字、下划线和$且不能以数字开头
命名规则
1）类名、接口名：采用名词，首字母大写，内含单词首字母大写
2）方法名：采用动词，首字母小写，内含单词首字母大写
3）变量名：采用名词，首字母小写、内含单词首字母大写
4）常量名：全部大写，单词间用下划线分开
注释 用于解释说明程序的文字
当行注释// 多行注释/* */ 文档注释/** */
作用：解释说明程序，提高代码的可读性
帮助我们调试程序
常量 一旦建立，在程序运行的整个过程中都不会改变。分字面值常量和自定义常量
字面值常量分类：
布尔常量：包括true和false
整型常量：表示所有的整数
浮点常量：表示小数
字符常量：用’ ’括起来的内容
字符串常量：用“ ”括起来的内容
空常量：null
有符号数据表示法
原码 补码 反码。计算机操作时，都是采用二进制的补码来计算的
原码：二进制最高位为符号位。1代表负 0代表正
组成：符号位+数值位
（补码计算 正数的值是其本身，负数的值是最高位（符号位）不变，其他位逐位取反，再加1）
（补码计算 两数相加，若最高位（符号位）有进位，则进位被舍弃
使用补码的好处：
1）可以将符号位和其他位统一处理
2）减法可以按假发来处理率
3）最高位不再表示数值，而是作为符号位，正好将数值这般，即一般是0至正数，一半是负数
反码：
正数的反码和其原码相同，负数的反码和原码符号位不变，数值位取反。
补码：
正数的补码和原码相同，负数的补码是在反码的末尾加1
计算机中正数和负数的关系是取反加一
补码运算是封闭的，运算结果保留在补码范围之内，超范围就溢出
4为二进制补码最多能够表示2^4个数，n为二进制补码最多能表示2^n个数
正数+负数=模
模是某种数据类型的总数
变量 在程序的执行过程中，在某个范围内其值可以发生改变的值
变量的定义格式：数据类型 变量名=初始化值；
java是强类型语言，对于每一种数据都定义了具体的数据类型，在内存中分配了不同的内存空间
数据类型：基本数据类型和引用数据类型
基本数据类型：整数（int 4字节、 short 2字节、 long 8字节、byte 1字节）、
浮点数（float 4字节、double 8字节）、
布尔类型（boolean）、
字符型（char 2字节）
注意事项
长整型long类型，后缀加L；float类型，后缀加F
变量的作用域
该变量定义在哪一级{}中，{ }即为该变量的作用域，且在该{}内不能同时定义同名的变量
离开作用域，变量所分配的内存空间将被JVM回收
初始化值：没有初始化的变量不可直接使用
在使用该变量之前必须初始化！！
数据类型的转换
Boolean类型不能转换为其他数据类型
Byte short char 相互之间不转换，他们参与运算都是先转换为int类型
默认转换：byte、short、char---int--->long--->float--->double
Long8字节 float 4字节long与float之间的转换？
1）他们底层的存储结构不同
2）Float表示的数据范围比long大
强制类型转换
目标类型 变量名=（目标类型）（被转换数据）；
引用数据类型：类（class）、接口（interface）、数组（[]）
Day03
数据类型中补充
1）定义Long或者float时，数据末尾要加L或者F，
2）整数类型默认为int，浮点型默认为double，
3）Byte\short定义时，接受的实际上是一个int类型数据。系统自己做检测，超过范围就报错
4）byte值问题
5）java中的char占用2个字节可以存储汉字，java采用Unicode编码
6）数据类型转换默认转换，：byte、short、char---int--->long--->float--->double
Float 4个字节 long 8个字节，flaot与Long之间的转换因为
A:它们底层的存储结构不同。
B:float表示的数据范围比long的范围要大
long：2^63-1
float：3.4*10^38 > 2*10^38 > 2*8^38 = 2*2^3^38 = 2*2^114 > 2^63-1
运算符
运算符的优先级（从高到低）
| 优先级 | 描述 | 运算符 |
| 1 | 括号 | ()、[] |
| 2 | 正负号 | +、- |
| 3 | 自增自减，非 | ++、--、! |
| 4 | 乘除，取余 | *、/、% |
| 5 | 加减 | +、- |
| 6 | 移位运算 | <<、>>、>>> |
| 7 | 大小关系 | >、>=、<、<= |
| 8 | 相等关系 | ==、!= |
| 9 | 按位与 | & |
| 10 | 按位异或 | ^ |
| 11 | 按位或 | | |
| 12 | 逻辑与 | && |
| 13 | 逻辑或 | || |
| 14 | 条件运算 | ?: |
| 15 | 赋值运算 | =、+=、-=、*=、/=、%= |
| 16 | 位赋值运算 | &=、|=、<<=、>>=、>>>= |
算术运算符
/ 整数相除只能得到整数，% 取余,只有整数（int,short,long）才能进行取余运算
++，++ 在前先自增，再参与运算，++ 在后先参与运算后自增。变量的自增
- -， -- 在前先自减，再参与运算， -- 在后先参与运算后自减。变量的自减
自增自减运算符，单独使用没有区别；参与运算使用运算结果会不同
+
加、正号、字符串连接符
做字符拼接，执行顺序从右至左
赋值运算符
=,+=,-=,*=,/=,%=
扩展的赋值运算符的特点：隐含了自动强制转换。
注意：== 等于 = 赋值
比较（关系）运算符
==等于 ！= 不等于 <= 小于等于 >=大于等于
特点：最终结果是boolean类型
逻辑运算符
&与 |或 ！非 ^异或 && ||
逻辑运算符用于连接boolean类型的表达式或值（true/false）
表达式：用符号把常量或者变量连接起来符合java语法规则的式子
& 有false则为false,都为true则为true
| 有true则为true，都为false则为false
^ 相同为false 不同为true
偶数次！，结果不改变
&&、||时，有短路效果
如果左边为真（假），右边参与运算，如果左边为假（真），那么右边不参与运算， 开发中常用这种。
&、|左右都参与运算
位运算符
先把数据转化为二进制进行运算。& | ^ ~ >> << >>>
&两边是布尔值进行逻辑运算，两边是数值进行位运算。有0则0
|运算 有1则1；^运算 相同则0不同则1；~按位取反，0变1，1变0；
^异或 运算特点：一个数被^两次，该数不变
<< 左移，左边最高位丢弃，右边补0
特点：左移，左边数据*2的移动次幂
>> 右移，最高位是0，左边补齐0，最高位1，左边补齐1
特点：右移，左边数据/2的移动次幂
>>> 无符号右移，无论最高位是0还是1，左边补齐0
三目运算符
比较表达式？表达式1：表达式2
Day04流程控制语句
程序执行过程中，执行顺序对结果有直接的影响，所以必须清楚程序的执行顺序而且通过流程控制语句的执行顺序来实现功能
顺序结构
由上至下，依次执行。
选择结构
有特定的语法规则，代码要执行特定的逻辑运算进行判断，逻辑运算的结果又2个，产生选择，按照不同的选择执行不同的代码
java提供两种选择结构语句
1）if语句
三种格式：
格式1：if(比较表达式) {
语句体 }
适合做单个判断
if语句注意事项：
A.比较表达式无论简单复杂，结果必须是boolean类型
B.if控制语句的语句体如果是一条语句，大括号可以省略，如果是多条语句，大括号不可以省略，建议永远不要省略
C.一般说，有左大括号就不要出现分号，有分号就没有左大括号
格式2：if(比较表达式){
语句体1 ; }
else{
语句体2; }
适合做2个判断
if语句格式2和三目运算符，完成相同的功能，区别：
能用三元就用三元，简单
三元运算符实现的都可以用if语句改进
当if语句控制的语句是输入语句时，不能用三元运算符改进，因为三元运算符是一个运算符，运算符操作完应该有一个结果，而不是一个输出。
格式3：if( 比较表达式1 ) {
语句体1 ;
} else if( 比较表达式2 ) {
语句体2;
}else if( 比较表达式3 ) {
语句体3；
}
........
else{
语句体 n+1;}
适合做3个判断
If语句使用场景
1）针对表达式是一个boolean类型的判断
2）针对一个范围的判断
2）switch语句
格式switch ( 表达式 ) {
case 值1：语句体1；
break;
case 值2：语句体2；
break;
.........
default: 语句体n+1；
break; //可以省略
格式注释：
表达式：取值是有限定的，byte,short,int,char. JDK5以后可以是枚举 JDK7以后可以是字符串
case 后是要和表达式比较的值
语句体 要执行的代码
break 表示中断结束的意思，控制switch语句的结束
default 当所有值和表达式不匹配是就执行default的语句体
注意事项：
1）case后面只能是常量不能是变量，而且，case后面的值不能相同
2）default可以省略，但是不建议，因为它的作用是对不正常的情况给出提示
3）break可以省略，但是会对程序产生影响，会出现case穿透，所以不建议省略
4）default可以出现在switch的任意位置，同样会出现case穿透，但是不建议，一般都放在最后
5）switch语句结束条件：break语句；执行到程序末尾
If语句和Switch语句的区别
If语句使用场景
1.针对结果是boolean类型进行判断
2.针对一个范围判断
3.针对几个常量值判断
Switch语句使用场景
1针对几个常量值进行判断
循环结构
在满足循环条件的情况下，反复执行某段代码，需要在合适的时候将循环条件循环改为false，停止循环。
循环语句组成：初始化语句，判断条件语句，循环体语句，控制条件语句。
for循环语句格式：
for(初始化语句 ; 判断条件语句; 控制条件语句 ){
循环语句体;
}
while循环
while( 判断条件语句 ){
循环体语句；}
扩展格式：
初始化语句；
while( 判断条件语句 ){
循环体语句；
控制条件语句；we}
for循环可以和while循环可以等价转换，但是有区别：
使用区别：控制条件语句所控制的变量，在for循环结束后，就不能在被访问了，而while循环结束后还可以继续使用，如果想继续使用，就使用while循环，否则推荐使用for循环，原因是：for循环结束，该变量就从内存中消失，，能够提高内存使用率。
场景区别：
for循环适合针对一个范围判断进行操作
while循环适合判断次数不明的操作
do ....while循环
do{
循环体语句;
控制条件语句; }
While(判断条件语句）；
一般情况下优先考虑for其次考虑while最后考虑do....while
循环中注意死循环：
1、一定注意控制语句的变量问题，如果丢了，容易出现死循环，特别注意while循环
2、两种简单的死循环格式： while(true) {.........}
for( ; ; ) ；
跳转控制语句
goto(),java保留字，java提供break,continue,return实现控制语句的中断跳转 break，使用场景：switch语句中，循环语句中（加入if判断语句）。离开使用场景没有意义。 退出当前循环
作用： 跳出单层循环，
跳出多层循环，必须使用带标签的跳出
带标签的跳出，格式：标签名 ：循环语句 标签名符合java命名规则
continue使用场景：循环语句中，离开使用场景没有意义
跳出一次循环，继续执行下一次循环
return不是结束循环体，不是结束循环而是退出方法
day05方法、
方法：完成特定功能的代码块，在很多语言中有函数的定义，在java中称方法
由{ },定义一个名字 方法的定义在类中
格式:
修饰符 返回值类型 方法名（参数类型 参数1，参数类型 参数2，...........）{
方法体;
return 返回值；}
参数：形式参数：就是方法定义上的，用于接收实际参数的值
实际参数：实际参与运算的，
参数类型：即参数的数据类型
return结束方法
返回值：功能返回的结果，由return带回
有明确返回值的调用，
1）单独调用，一般无意义
2）输出调用，有意义但不够好，因为可能需要对结果进行进一步的操作
3）赋值调用，先用一个变量接受方法的结果在进行操作
方法的注意事项;
1)方法不调用不执行
2)方法之间是平级关系不可以嵌套使用
3)方法定义时参数之间用 ，隔开
4)方法在调用的时候不用再传递数据类型
5)如果方法有明确的返回值，一定要用return返回一个数据
返回值不明确的方法的调用
单独调用即拿名字给参数
输出调用，不可以使用
赋值调用，不可以使用
方法的重载
在同一个类中，允许存在相同的方法名，只要他们的参数个数或参数类型不同即可
方法重载特点：
与返回值类型无关，只要参数列表不同即可
方法调用时由java虚拟机通过参数列表的不同来区分同名方法
数组
存储多个变量的容器，且多个变量的数据类型相同，
每个元素都有编号，编号从0开始，最大为数组长度-1，编号也叫索引
数组：是存储同一数据类型的多个元素的集合。 数组既可以存储基本数据类型，也可以 存储引用数据类型
定义格式：
格式1： 数据类型[] 数组名 推荐使用
格式2：数据类型 数组名[] 看懂即可
数组初始化
java中数组初始化后才可以使用，初始化就是为数组中的数组元素分配内存空间，并为每个元素赋值。
数组初始化方式：
动态初始化：初始化时，只指定数组长度，由系统为数组分配初始化值
格式：数据类型[] 数组名=new 数据类型 [ 数组长度 ]
举例; int[] arr = new int[3];
数组名[索引] 获取数组中的元素值
静态初始化：初始化时指定数组中元素的值，由系统决定数组长度
格式：
举例： int[] arr = new int[]{1,2,3};
简化 int[] arr = {1,2,3};
java中的内存分配：
java程序为了提高程序运行效率，就对数据进行了不同空间的分配，每一块内存空间都有特定的数据处理方式和内存管理方式
栈 存储局部变量
堆 存储new出来的东西
方法区
本地方法区(与系统相关)
寄存器（CPU使用）
局部变量：在方法定义中或者方法声明上的变量称为局部变量
堆内存特点：
1）每一个new出来的东西都有地址值
2）每个变量都有默认值。byte int short long 默认值 0 float double默认值0.0 char默认值 \u0000 boolean默认值 false 引用类型 默认值 null
3）使用完毕就变成了垃圾，并没有立即回收，会在垃圾回收器空闲时回收
堆空间
1）堆控件存取数据的效率最低
2）数据存放的位置随机分配
3）堆空间存储数据的空间大，能存放大容量的数据
栈内存特点：
1）栈内存数据用完就释放掉
栈空间
1）栈空间存取数据的效率高
2）栈中的数据按“先进后出”的方法管理
3）栈空间存储空间较小，不能存放大量的数据
4）JVM将基本类型的数据存放在栈空间
数组操作的2个常见小问题
1） java.lang.ArrayIndexOutOfBoundsException: 数组元素下标越界
2） NullPointerException空指针异常，原因：数组已经不再指向堆内存，而用户用数组名去访问。arr=null； arr[0];
Day06二维数组
二维数组：每一个元素都是一个一维数组
定义格式：
格式1：数据类型[][] 数组名=new 数据类型[m][n]；
m表示这个二维数组有多少个一维数组
n表示每一个一维数组元素的个数
该格式定义时已经为数组及数组中的元素开辟空间
案例：int[][] arr=new int[3][2];
格式2：数据类型[][] 数组名=new 数据类型[m][]
m表示这个二维数组有多少个一维数组
数组元素的个数可以动态给出，即列是变化的
案例：int[][] arr=new int[3][];
格式3：数据类型[][] 数组名=new 数据类型[][]{{元素1，元素2，...},{元素1，元素2，...},{元素1，元素2，...}......}
简化版 数据类型[][] 数组名={{
元素1，元素2，...},{元素1，元素2，...},{元素1，元素2，...}......}
案例：二维数组遍历，求和
杨辉三角形
java中参数传递问题
基本类型，传递的是数据值，值传递。形式参数的改变对实际参数没有影响
引用类型，传递的是地址值，形式参数的改变直接影响实际参数的值
Day07面向对象
面向对象思想
面向对象是基于面向过程的编程思想
面向过程：每一个功能的步骤
面向对象：强调的是对象，然后由对象调用功能
面向对象的思想特点：
1）是一种更加符合我们思想习惯的思想
2）可以将复杂的事情简单化
3）将我们从执行者变成了指挥者
举例：买电脑
面向过程：了解电脑-->了解自己的需求-->找对应的参数信息-->去电脑城买电脑-->讨价还价--.电脑买好
面向对象：知道自己买电脑-->熟人去买电脑-->电脑买回来了
面向对象开发，设计，特征
面向对象开发：就是不断的创建对象，使用对象，指挥对象做事情
面向对象设计：就是管理和维护对象之间的关系
面向对象特征：继承inheritance，封装encapsulation，多态polymorphism
类与对象及其使用
类--java中最基本的单位
属性：就是该事物的描述信息-------成员变量
行为：就是该事物可以做什么-------成员方法
类：是一组相关的属性和行为的集合，是一个抽象的概念
对象：是该类事物的具体存在个体
类的定义：即定义成员变量，成员方法
类的使用
* 创建对象使用格式： 类名 对象名=new 类名();
* 如何使用成员变量对象名.变量名
* 如何使用成员方法 对象名.方法名();
注意方法有参数
对象内存图
栈，堆，方法区。 方法所有对象共享，变量各自开辟空间，且使用完毕后都释放内存。两个引用指向同一个对内存。
成员变量和局部变量的区别
1）类中位置不同
成员变量：类中方法外
局部变量：方法定义中或方法声明上
2）在内存中位置不同
成员变量：在堆内存
局部变量：在栈内存
3）生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法调用结束而消失
4）初始化值不同
成员变量：有默认初始化值
局部变量：没有默认初始化值，必须定义赋值，才可以使用
注意事项：局部变量和成员变量名可以相同，在方法中使用时采用就近原则
形式参数：
基本数据类型，形式参数的改变不影响实际参数的值
引用数据类型，形式参数的改变直接影响实际参数的值
如果一个方法的形式参数是引用类型（类类型），这里其实需要的是该类的具体对象
匿名对象
匿名对象：就是没有名字的对象。new类名（）；
应用场景：1）调用方法，仅仅只调用一次，调用多次不适合
好处：匿名对象使用完毕就是垃圾，可以被垃圾回收器回收
匿名对象可以作为实际参数传递
封装
封装:是指隐藏对象的属性和实现细节，仅对外提供公共访问方式
封装：类、方法、private修饰成员变量
好处：1）隐藏实现细节，提供公共的访问方式
2）提高代码的复用性
3）提高安全性
封装原则：
1）将不需要对外提供的内容隐藏起来
2）把属性隐藏，提供公共的方法对其进行访问
private是封装的一种形式
private修饰成员（成员变量和成员方法），只能被本类访问，对外提供公共的访问方法。
private常见应用：把成员用private修饰 提供对应的getXX()和setXX()方法
this关键字
this 1）代表当前对象的一个引用，即当前对象的一个类。那个对象调用该方法this就代表那个对象。
场景：解决局部变量隐藏成员变量
this还有其他应用- - - - - - - - - - -
构造方法：construction
作用：给对象的数据初始化
格式： 1）方法名与类名同名
2）方法无返回值类型，连void也没有
3）没有具体的参数
构造方法中可以有return();空语句，表示结束方法，任何返回值为void类型的方法都可以有return语句
注意事项：
1、如果没有给出构造方法，系统自动给出一个无参构造方法
2、如果给出了构造方法，系统将不再提供默认的无参构造方法 注意这是需要用无参构造函数，必须自己给出，建议永远自己给出
成员方法具体划分：
1）根据是否有返回值
void类型，非void类型
2）根据形式参数
空参数，非空参数
成员变量定义：如果某变量是用来描述该类的信息，应该定义为成员变量
变量的定义范围越小越好，因为可以及时被回收。
Static关键字
针对一个对象共享多个变量，java提供关键字static修饰
static关键字特点：
1）随着类的加载而加载
2）优先于对象存在
3）被类的所有对象共享。 如果某个成员变量被所有对象共享，应该定义为静态
4）可以通过类名调用，其实本身也可以通过对象调用。推荐使用类名调用，静态的东西称其为与类相关的，即类成员
static注意事项：
1）在静态方法中没有this关键字
2）静态方法只能访问静态成员变量和静态成员方法
静态变量和成员变量的区别
1）所属不同
静态变量属于类，所以也称类变量
成员变量属于对象， 所以也称为实例变量（对象变量）
2）内存中位置不同
静态变量存储于方法区的静态区
成员变量存储于对内存
3）内存出现时间不同
静态变量随着类的加载而存在，随着类的消失而消失
成员变量随着对象的创建而存在，随着对象的消失而消失
4）调用不同
静态变量可以通过类名调用，也可通过对象名调用
成员变量只能通过对象名调用
main()方法格式讲解
public static void main(String[] args)
public公共的，访问权限是最大的。因为main方法是由JVM调用的，所以权限要足够大
static静态的，不需要创建对象通过类名就可以，方便JVM调用
void因为方法的返回值是给调用者的，而main方法是被JVM调用的，返回给JVM是没有意义的
main常见的方法入口
String[] args字符串数组，早期是为了接收键盘录入数据
格式java mainDemo hello world java 了解
Day08
帮助文档的制作，java提供对应的API文档
代码块
在java中，用{}括起来的代码称为代码块
根据位置和声明不同，分类为：
静态代码块
局部代码块
构造代码块
同步代码块（多线程）
* 局部代码块：在局部位置， 方法中，每次都执行，用于限定方法的生命周期
* 构造代码块：类中的成员位置，类中方法外、把多个构造方法中相同部分提取出，每次调用构造方法前都执行
* 静态代码块：类中的成员位置，类中方法外，只执行一次，用static修饰，作用:一般为类进行初始化
* 执行顺序：静态代码块-->构造代码块--->局部代码块
继承
继承：多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无须再定义这些属性的行为，只需继承该类即可
通过关键字extends实现类与类的继承
格式： class 子类 extends 父类{ }
继承的好处：
1）提高了代码的复用性
多个类的相同成员可以放到同一个类中
2）提高了代码的维护性
如果功能的代码需要修改，只修改一处即可
3）让类与类之间产生了关系，是多态的前提
这也体现了继承的弊端：类的耦合性很强
java只支持单继承不支持多继承
即一个类只能有一个父类不能有多个父类
java支持多层继承（继承体系）
注意事项
1）子类只能继承父类所有非私有成员（成员方法和成员变量）
其实这也体现了继承的另一个弊端打破了封装性
2）子类不能继承父类的构造方法，但可通过关键字super去访问父类的构造方法
3）不要为了部分功能而去继承
super关键字
super,代表父类存储空间的表示
this，代表当前对象的引用，本类对应的引用
用法
访问成员变量
this.成员变量 super.成员变量
访问构造方法(子父类的构造方法问题讲)
this(…) super(…)
访问成员方法(子父类的成员方法问题讲)
this.成员方法() super.成员方法()
继承中构造方法的关系
子类中所有构造方法默认都会访问父类中的无参构造方法，原因：因为子类会继承父类的中的数据，可能还会使用父类的数据。所以，子类在初始化之前，一定要先完成对父类数据的初始化。
每一个构造方法的第一条语句默认都是：super()
如果父类中没有构造方法时
1）子类通过super去显式调用父类其他的带参的构造方法
2）子类通过this去调用本类的其他构造方法
3）本类其他构造也必须首先访问了父类构造
一定要注意：
super(…)或者this(….)必须出现在第一条语句上
否则，就会有父类数据的多次初始化
继承类中成员方法的关系
方法的覆盖：子类中出现和父类中一模一样的方法声明
使用特点：
如果方法名不同，就调用对应的方法。如果方法名相同，最终使用的是父类自己的。
方法覆盖的应用
当子类需要父类的功能时，而功能主体子类有自己特有的内容时，可以重写父类中的方法，这样既沿袭了父类的方法，又定义了子类特有的功能。
方法覆盖（方法重写）的注意事项
1）父类中的私有方法不能被重写
2）子类重写父类方法时，访问权限不能降低
3）父类静态方法，子类也必须通过静态方法重写
Day09 final关键字
final:最终，可以修饰类、变量、方法
特点：
final修饰类：该类不能被继承
final修饰方法：该方法不能被重写
final修饰成员：该变量不能被重新赋值，可以看做为一个常量，只能被赋值一次
final修饰成员变量
基本数据类型：值不可以改变
引用数据类型：地址值不可以发生改变，但是对象的内容可以改变
多态
某一个事物，在不同的时刻表现出来的不同状态
多态的前提和实现
1）有继承关系
2）要有方法重写
3）要有父类或父接口引用指向子类对象 父 f =new 子();
多态中成员访问特点
1）成员变量
编译运行都看左边，即父类
2）构造方法
创建子类对象的时候访问父类的构造方法，对父类数据进行初始化
3）成员方法
编译看左边，运行看右边。因为成员方法存在方法重写
4）静态方法
译运行都看左边，即父类
多态的好处
1）提高了代码的维护性（继承保证）
2）提高了代码的扩展性（多态保证）
多态的弊端
1）不能使用子类特有的功能
如何使用子类中的特有功能：
创建子类对象调用特有方法（可以，不合理，而且占内存）
把父类引用强制转化为子类引用（向下转型）
多态中转型问题
向下转型
从子到父
父类引用指向子类对象
向上转型
从父到子
子类引用指向父类对象
抽象类
抽象类：具有抽象功能（即不是一个具体的功能）的类
抽象类的特点：
1）抽象类和抽象方法必须用abstract修饰
2）抽象类中不一定有抽象方法，但是有抽象方法的类必须定义为抽象的
3）抽象类不能实例化
因为它不是具体的类，
抽象类有构造方法，但是不能实例化，作用：用于子类访问父类数据的初始化
4）抽象类的子类
。抽象类的子类是一个抽象类
。重写所有的方法，子类是一个具体的类
抽象类成员方法特性
1）抽象方法，强制要求子类做的事情。抽象方法没有方法体，仅有声明
2）非抽象方法：子类继承过去的东西，提高代码的复用性
抽象类中的小问题
1）一个类如果没有抽象方法，可不可以定义为抽象类，如果可以，有什么意义？
可以。 外界不可以创建对象，必须通过子类访问
2）抽象类和那些关键字不可以共存
private 冲突，抽象方法必须被重写而私有不能被重写
final 冲突，抽象方法必须被重写而final修饰的不能被重写
static 无意义，
接口
接口：interface，把用于完成特定功能的若干属性组织成相对独立的属性集合，凡是 需要实现这种特定功能的类，都可以继承这个属性集合并在类中使 用它，这种属性集合称为接口
接口的特点：
1）用关键字interface表示 interface 接口名{ }
2）类实现用implements表示 class 类名 implements 接口名{ }
3）接口不能实例化
但可以按照多态的方法实例化
多态的使用：
A:具体类多态（几乎没有）
B.抽象类多态（常用）
C.接口多态（最常用）
4）接口的子类
可以是抽象类，但意义不大
是具体类，要重写出接口中的所有抽象方法（推荐）
接口成员特点：
* 成员变量：接口中变量默认为常量，并且是静态的
* 默认修饰符 public static final
* 成员方法：接口方法必须是抽象的
* 默认修饰符：public abstract
* 构造方法：接口没有构造方法
*类与类关系：
继承关系、只能单继承不能多继承，可以多层继承
*类与接口关系：
实现关系，implements，可以单实现，也可以多实现，并且可以在继承一个类的同时实现多个接口，实现多个接口时，注意对应的对象调用对应的方法
*接口与接口关系：
继承关系：可以单继承也可以多继承
抽象类和接口的区别
1）成员区别
抽象类
成员变量：常量’变量；构造方法：有；
成员方法：抽象方法、非抽象方法
接口
成员变量：常量；构造方法：无；成员方法：抽象方法
2）关系区别
类与类：继承关系，单继承
类与接口：实现关系，单继承，多实现
接口与接口：继承，单继承，多继承
3）设计理念区别
抽象类，被继承体现的是“is a”的关系。抽象类中定义的是该继承体系的共性功能
接口，被继承的是”like a”的关系。接口中定义的诗该继承体系是扩展功能
形式参数和返回值问题深入版
形式参数类型：
基本类型（省略）
引用类型
1、类，类作为形参，实际传递的是该类的对象
2、抽象类，抽象类作为形参，实际需要的是该抽象类的子类对象，多态创建对象
3、接口，接口作为参数，实际需要的是该接口类的对象
返回值类型：
基本类型（省略）
引用类型
1、类，返回的是该类的对象
2、抽象类，返回的是该抽象类的子类的对象
3、接口，返回的是实现该接口的具体类的对象
链式编程
对象.方法().方法().方法().....
这里每一个方法返回的都是一个对象，最后一方法返回的可以不是对象
包的概述
包：其实就是文件夹。
作用：1）对类进行分类管理 2）相同的类名可以存放到不同的包中
包的定义：格式 package 包名
注意事项：
1）package语句必须是程序第一行代码
2）package文件在一个java文件中只能有一个
3）如果没有指定包名，默认无名包
import关键字，导包，格式：import 包名；--->导入到类的名称
权限修饰符
修饰符
权限修饰符：private、默认、protected、public
状态修饰符：static 、final
抽象修饰符：abstract
类：
权限修饰符: 默认、public 状态修饰符：final 抽象修饰符：abstract
成员变量：
权限修饰符：private、默认、protected、public 状态修饰符：static 、final
构造方法
权限修饰符：private、默认、protected、public
成员方法：
权限修饰符：private、默认、protected 、public 状态修饰符：static 、final
抽象修饰符：abstract
内部类
内部类：把类定义在另一个类中，该类就称为内部类
访问特点：
1）内部类可以直接访问外部类的成员包括私有
2）外部类访问内部类的成员，必须创建对象
内部类的位置
1）成员位置：成员内部类
#如何直接访问内部类
成员内部类的修饰符
private为了保证数据的安全性
Static 为了方便访问数据
static修饰的成员内部类如何直接访问
*内部类和外部类没有继承关系
2）局部位置：局部内部类
#可以直接访问外部类成员
#在局部位置，可以创建内部类对象，通过对象调用内部方法，来使用内部功能
局部内部类访问局部内部对象的注意事项
A、可以直接访问外部类的成员
B、在局部位置可以创建对象，通过对象调用该内部类的方法，来使用内部类的功能
C、局部内部类访问成员变量必须用final修饰
原因：因为局部变量随着方法的调用而调用，随着调用完毕而消失，然而，堆内存 中的内容不会消失，所以加final修饰，被final修饰后，该变量的值不会改变， 即变成常量
匿名内部类
即局部内部类的简化写法。
前提：有一个接口或类（具体类、抽象类都可以）
在开发中，若抽象类或者接口作为形式参数传递，此时传递的实际是该子类的一个对象，如果只使用一次可以用匿名内部类改进
83
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
