java学习重点笔记专业资料.doc

Java学习笔记

Java概述
java语言是解释执行，java源码是通过编译生成一种特殊.class中间字解码文献，然后再有JVM进行解释执行。

java语言对指针进行了上层封装，它保证可以通过这个指针（引用）来访问有效内存单元。

java语言不容许多继承，使继承关系成树装图，每个类都只能由一种父类。

java语言开发效率高，但执行效率低。（相称于c++55%）

java垃圾回收机制，在java中new对象不需要向c++同样进行delete操作，JVM会依照状况回收垃圾对象。（懒汉机制，等待资源没有时候才回收）咱们只可以建议JVM进行垃圾回收，例如（System.gc() RunTime.gc()这两个办法就是建议JVM进行垃圾回收办法）

JDK，java开发工具包（类库和运营命令），JRE，java运营环境，JVM，java虚拟机（解释执行核心，对字节码进行翻译成运营环境机器码，它可以屏蔽平台差别。JVM是不跨平台。）
JAVA_HOME,指明JDK安装位置，CLASSPATH，指明类文献位置，PATH，指明命令可执行文献位置。

java源文献文献名必要和文献中定义public class类名（大小写页要相似）相似。

java源代码中main办法定义写法。main办法是程序入口。
public static void main(String[] args){
System.out.println("Hello world")；
}
java源文献也要先编译，使用javac xxx.java格式命令得来编译，使用java xxx来运营。
定义包构造要放在有效代码第一行，package xxx.xxx，包定义在一种程序中只能由一种，在加上包定义之后编译可以使用javac -d 途径 xxxx.java,这个-d这个命令行参数可以指定包构造位置“.”代表当前目录。在运营时要使用类全名

java xxx.xxx.xxxx用包名以点分隔。运营时要在包构造上一层目录来运营。

java中注释
单行注释 //......
多行注释 /* .......*/
文档注释/** ........<p>(换行标签)*/,用javadoc命令可以依照原码中文档注释生成注释文档（html格式）。文档注释中可以使用html标签。
javadoc -d 途径 （指定注释文档保存途径）
文档注释普通写在类定义之前，办法之前，属性之前。
在文档注释中可以用 @author 表达程序作者，@version 表达程序版本，前两个注释符号要写在类定义之前，用于办法注释@param 对参数进行注释,@return 对返回值进行注释 @throws对抛出异常注释。

jar命令用于打一种xxx.jar文献
用法：jar {ctxu}[vfm0Mi] [jar-文献] [manifest-文献] [-C 目录] 文献名 ...
选项：
-c 创立新存档
-t 列出存档内容列表
-x 展开存档中命名（或所有〕文献
-u 更新已存在存档
-v 生成详细输出到原则输出上
-f 指定存档文献名
-m 包括来自标明文献标明信息
-0 只存储方式；未用ZIP压缩格式
-M 不产生所有项清单（manifest〕文献
-i 为指定jar文献产生索引信息
-C 变化到指定目录，并且包括下列文献：
如果一种文献名是一种目录，它将被递归解决。
清单（manifest〕文献名和存档文献名都需要被指定，按'm' 和 'f'标志指定相似顺序

示例1：将两个class文献存档到一种名为 'classes.jar' 存档文献中：
jar cvf classes.jar Foo.class Bar.class
示例2：用一种存在清单（manifest）文献 'mymanifest' 将 foo/ 目录下所有
文献存档到一种名为 'classes.jar' 存档文献中：
jar cvfm classes.jar mymanifest -C foo/ 。
普通在使用使用jar cvf 文献名.jar 文献所在途径（xxx/xxx/xxx.class）也可以压缩一种目录,只要在制定途径是指定为文献夹，jar命令命令行参数在使用时可以以“-”开头，也可以不用。

java程序运营过程，一方面是启动java虚拟机，然后就是去找.class文献，先是从系统类库中找（系统之会在跟目录下查找，因此需要完整类名），如果找不到话会去CLASSPATH所设立目录去找。然后加载到java虚拟机中。
系统会在每个java程序中隐含导入了java.lang这个包，import 包名，导入包中类文献。
java.lang包，这是一种基本包。
java.util包,这个包是工具类包。
java.io包,这个包是用于输入输出操作
包,这个包是用于网络编程。
java.awt，java.swing，javax.swing，java.event等包用于图形编程用包。
applaction java应用程序，java应用程序中必要有一种main()办法。

标记符和核心字

Java代码中“；”、“{}”、“ ”
Java语句以分号分隔，Java代码块包括在大括号内，忽视空格.标记符
1) 用以命名类、办法和变量、以及包遵守JAVA命名规范类以每个单词都以大写字母开头。办法和变量第一种字母不大写，其她照旧。
2) 只能以字符、“_”或“$”开头；
3) 无长度限制。

java中核心字
goto和const在java中虽然不再使用但是还作为核心字存在
java中没有sizeof这个核心字了，java中boolean类型值只能用true和false，且这两值也是核心字。
java语言中没有无符号这个核心字（unsigned）

java中数据类型
1) 整型
byte 1字节 8位 -128到127
short 2字节 16位 -2^15到2^15-1
int 4字节 32位 -2^31到2^31-1
long 8字节 64位 -2^63到2^63-1
2) 浮点类型
float 4字节 32位
double 8字节 64位
3) 字符类型
char 2字节 16位
4) 布尔型
boolean false/true

注：1) char是无符号16位整数,字面值必要用单引号括起来； ‘a’
2) String 是类，非原始数据类型；
3) 长整型数字有一种后缀为“L”或“l”，八进制前缀为“0”，十六进制前缀为“0x”；
4) 黙认浮点类型为double；
5) float数据类型有一种后缀为“f”或“F”,Double数据类型后可跟后缀“D”或“d“
6)char类型也可以用通用转译字符，但是不能用ASCII码。可以用“\u0000”这种格式，由于char型中使用是unicode编码方式。

注：整型值存储，正数存储原码（二进制码），负数则存储补码（原码按位取反末位加一）。

注：实型值在存储时会损失精度，因此不要直接比较两个实型值。系统默认实型都是double型，要使用时要在数据后加个f，或者强行转换。强转（占字节数大类型转到占字节数小类型）时会放弃高位值只取低位值。

java中数字数据类型减灾由占字节数小类型到占字节数大类型可以有自动转换，反之则需要强行转换，char型和int型之间可以互相转换。char和short不能像户转换。

注意：隐式类型转换；
a 运算符 b ，如果a，b中有任意一种是double型，前面运算成果就是double型，如果a，b中有任意一种是float型，前面运算成果就是float型，如果a，b中有任意一种是long型，前面运算成果就是long型，如果a，b中没有double、float、long型，那么其成果就为int型。

所有基本数据类型在使用时会事先分派空间，只自身就存在空间中，在传递时，就是值传递，不是引用传递。

在类中定义办法在返回值前加上static修饰符就可以在main办法中调用了。如果不用static那就需要在main办法中创立对象，使用对象来调用对象办法。
public class Test{
public static void main(String[] args){
Test t=new Test()；
int b=1；
int c=2；
int[] a=new int[10]；
t.sqort(a)；
add(b,c)

}
public int[] sqort(int[] a){
.......
}
static int add(b,c){
.......
}
}

java中运算符（java运算符优先级和结合性和c++相似）

System.out.println(3/2) 按整型计算 得1
1) >>= 前面是零补零，前面是一补一；
2) >>>= 无符号右移（强制右移都会移进一），
>>=和>>>=对于负数不同样
正数：右移n位等于除以2n次方
负数：变成正数。
3) && 短路与，前面为假，表达式为假，背面操作不会进行，& 会对所有条件进行判断。
4) || 短路或，前面为真，表达式为真，背面操作不会进行，| 会对所有条件进行判断。
例：
if(a<3&(b=a)==0) b赋值
if(a<3&&(b=a)==0) b不赋值
5)instanceof，是用于判断一种对象与否属于某个类型
6)java中求余运算符“%”可以对两个实型变量求余

注：按位与是为了让某些位置一，按位或是令某些位置零，按位异或是令某些位取反。

注：使用左右位移和无符号右移运算符用法是 变量名<<=位移位数 ，变量名>>=位移位数 (前两个运算符是不会忽视整形符号位，也称逻辑位移),变量名>>>=位移位数

注意：左右位移和无符号右移运算符只能用于整形及其兼容类型（byte，int，short，long）

注意：java程序运营过程，一方面是启动java虚拟机，然后就是去找。class文献，先是从系统类库中找（系统之会在跟目录下查找，因此需要完整类名），如果找不到话会去CLASSPATH所设立目录去找。然后加载到java虚拟机中。如果要使用到其她在JAVA_HOME中没有类或者是其她公司提供第三方。jar（jar包）文献时，要把它途径及文献名加到CLASSPATH中。

java流程控制
控制流
if()
if()….else
if()…..else if()….else

注意：else只是和其上面同层近来if()来配对。

switch(){
case 'a':……..
case 1:……break；
default:
…………
}
注解：switch()内数据类型为byte short char int类型，只有以上四种类型才可以在switch()中使用。case块中不加break时顺序执行下面语句。

循环语句

for(int i=0；i<n；i++){}
while(){}
do{} while()；-----------注意加分号

例子：
loop:for(int i=0；i<n；i++)
{
for(int j=0；j<m；j++)
{
if(3==j)
{
break loop；//--loop为标签只能用在循环语句中，用于循环跳到外层循环
}
}
}

辨析：
int x,a=6,b=7；
x=a++ + b++； //----------a=7,b=8,x=13
int x=6；x=~x；//---------------- 6二进制0110 取反得11001 再转成补码（取反加一） 10111 ＝ －7

break，跳出本层循环，执行背面代码，continue，提前终结本次循环，再一次进行循环或循环条件满足或不满足后退出循环。break 标签名； continue 标签名；这两条语句知识表达跳出有标签循环和提前终结本次有标签循环，只能用在循环语句（多层循环嵌套）中，循环嵌套中用于跳到外层循环。

注意：for循环在使用时一定要注意不要忘掉()中两个"；"，死循环写法for(；；){}或者是用
while(true){}

注意：System.out.println("..."+a)在使用这个语句时，它会将其中非字符串（String）值转换成字符串（不是所有数据类型都可以）。
java中数组Array，其包括两个某些，分别是数组引用和数组空间两某些。

声明数组
1) 一组相似类型(可以是类)数据集合；
2) 一种数组是一种对象；
3) 声明一种数组没有创立一种对象；
4) 数组能如下列形式声明：
int[] i 或 int i[]
Car[] c 或 Car c[]
*C++中只能 Car c[]
*JAVA中推荐用 Car[] c；
5)数组定义 如：
int[] a（数组引用声明）=new int[10]（数组空间声明，并把空间首地址赋值给数组引用）
int[] a；
a=new int[20]；

创立数组
1) 创立基本数据类型数组 int[] i = new int[2]；
2) 创立引用数据类型数组 Car[] c = new Car[100]；
3) 数组创立后有初始值。
数字类型为0 布尔类型为false 引用类型为null

注意：访问没有初始化数组中值，是会抛出异常（NullPointerException）,java中只保证一位数组地址是持续，二维数组事实上是一维数组中有存储了一维数组引用。

初始化数组
1) 初始化、创立、和声明分开
int[] i；
i = new int[2]；
i[0] = 0；
i[1] = 1；
2） 初始化、创立、和声明在同一时间
int[] i = {0,1}；
Car[] c = {new Car(),new Car()}；

多维数组
1） 有效定义
int[][] i1 = new int[2][3]； （同步给定一维，二维空间）
int[][] i2 = new int[2][]； （给定一维空间，二维空间待定）
i2[0] = new int[2],i2[1] = new int[3]；
*C++中 int[][] =new int[][3]；有效
2） 无效定义
int[][] i1 = new int[][3]；
3） 数组长度 ------------数组属性length（在二维数组中这个属性只代表第一维长度）
int[] i = new int[5]；
int len = i.length；//len = 5；
Student[][] st = new Student[4][6]；
len = st.length；//len = 4；
len = st[0].length；//len = 6；

数组拷贝
System.arrayCopy(Object src，int srcPos，Object dest，int destPos，int length)；
src源数组，srcPos从第几位开始拷贝，dest目的数组，destPos目的数组放置起始位置，length，表达要拷贝长度。
拷贝一种数组到另一种数组。

类对象创立和对象数组

一种xxx.Java文献中可以定义各种类但是只能由一种public修饰类，也只能以这个类类名作为.java文献名。

java中类对象创立，要先创立这个对象引用， 例如：Car c；然后用new这个核心字创立一种对象实例（对象空间） 例如：c=new Car()；，然后对象实例空间首地址赋值给对象引用。各种对象引用可以同步引用自同一种对象实例，但是对象引用只能引用一种对象实例。

对象引用和对象实例间就像是牵着气球线和气球同样。

注意：只有一种没有被任何 对象引用 所引用 对象实例才会边城垃圾等待被垃圾回收。

对象数组

例：Car[] c=new Car[3]；
c[0]=new Car()；

注意：存储基本类型数组数据是直接存储在数组空间中，而对象数组在数组空间中存储则是对象引用。

定义在类中类属性是实例变量，定义在类办法中变量是局部变量。实例变量是保存在对象空间中，而局部变量则是在办法调用分派空间，调用结束后就释放空间。

注意：在类定义中属性定义和办法定义 必要写在类里。

注意：系统会自动初始化实例变量，数字类型为0 ，布尔类型为false ，引用类型为null。局部变量需要初始化，必要赋初值。如果不赋初值无法通过编译。

Java中办法调用中参数传递有两种，一种是对于参数是基本类型使用是值传递（直接传参数值），另一种是引用传递，它是用于参数是类对象，它传递是这个对象引用。

面向对象思想

anything is Object（万物皆对象）

抽象，从对详细对象中抽取有用信息。
对象有其固有属性，对象办法，即对象行为（对象能做什么）
对象自身是简朴（功能简朴），各种对象可以构成复杂系统（对象之间彼此调用对方办法）

对象应当是各司其职（功能简朴），各尽所能（把自己功能作到最佳）。（弱耦合性实现了前面所述对象特点）

对象耦合性，是对象之间联系，对象和系统之间联系。对象耦合性要尽量弱，也就是对象之间联系尽量弱，对象和系统之间联系尽量弱。
系统可插入性，是在系统中加入新对象之后系统稳定性。
对象可替代性，是在系统中替代原有对象之后系统稳定性。
复用性，即对象可否被重复使用，对象功能越简朴，复用性就越好。（对象耦合性弱，复用性就比较强）

面向过程是先有算法，后又数据构造（怎么解决问题）
面向对象是先有对象（数据构造），后有算法。（用什么做）

类是某些有着相似属性集合抽象。
类是一种类对象模板，对象是类详细化。
类是一种新数据类型，类对象。

注意：局部变量作用范畴是在定义她代码块以内，局部变量要先赋值后使用，在以一种重叠作用于范畴内不容许两个局部变量命名冲突。局部变量局部优先，且在于实例变量同名时会副该局部变量。

变量 涉及简朴变量（原始数据类型），对象变量。

办法定义：
1，办法修饰符（各种修饰符浮现顺序无关） |
2，办法返回值类型 |顺
3，办法名 |序
4，办法参数表 |向
5，办法中容许抛出异常 |下

java中不可以在返回语句后写任何代码。JVM+解释器=JRE，JRE+类库=JDK

java中办法重载（overload）办法名相似，参数表不同，返回值类型可以不同。调用时要给出明确参数并拟定调用某一办法。在编译时，编译器会依照参数选取恰当办法，因此重载也叫编译时多态。

就近向上匹配原则
如果办法参数表中数据类型和调用时给出参数类型不尽相似时会依照向上匹配就近原则。（类型就近向上转化匹配）
注意：调用时要给出明确参数并拟定调用某一办法，否则编译会出错。

对象使用者（调用其她对象办法）对象（对象中办法被调用时依照参数进行自己进行选取）
一类办法，但跟据不同参数会有差别，对象回依照参数判断，对对象调用者透明。

创立对象过程：1，分派空间 2，初始化属性 3，调用构造办法（有前提，不考虑继承关系）

构造办法写法：没有返回值类型，构造办法办法命名必要和类名相似。如果在类中不写构造办法，系统会提供一种无参构造办法。

注意：最佳在写类时提供一种无参构造办法。

获得对象方式
通过new（在堆空间中申请分派空间），new 类名（），可以通过这种形式或一种对象，这时对象是无法使用，必要把她地址存储近一种对象变量才可以使用。例如 ：Car c=new Car()；
有参构造办法在被调用时，在用new核心字或对象时初始化，例如：Car c=new Car("yellow")

对象变量中存储是对象引用（地址封装形式）

this核心字
表达当前对象（哪个对象调用了办法，哪个对象就是当前对象），可以用来区别实例变量和局部变量。this(),她表达掉用本类其她构造办法，注，只能写在构造办法第一行。

java中参数传递，简朴类型变量传递是数值，对象变量传递则传递一种引用（地址）

面向对象三大特性
封装、继承、多态。

java中封装

封装，一种对象和外界联系应当通过一种统一接口，应当公开公开，应当隐藏隐藏。（对象属性应当隐藏），一种对象内部是透明，就是把对象内部可透明性和隐藏特性区别开，该透明透明，该隐藏隐藏。

（封装属性）java中类属性访问权限默认值不是private，要想隐藏该属性或办法，就可以加private（私有）修饰符，来限制只可以在类内部进行访问。

对于类中私有属性，要对其给出一对办法（getXxx(),setXxx()）访问私有属性，保证对私有属性操作安全性。

办法封装
对于办法封装，该公开公开，该隐藏隐藏。办法公开是办法声明（定义），即（只须懂得参数和返回值就可以调用该办法），隐藏办法实现会使实现变化对架构影响最小化。。

封装会使办法实现变化对架构影响最小化。
完全封装，类属性所有私有化，并且提供一对办法来访问属性。
java中继承

继承，是对有着共同特性多类事物，进行再抽象成一种类。这个类就是多类事物父类。父类意义在于可以抽取多类事物共性。

java中继承要使用extends核心字，并且java中只容许单继承，也就是一种类只能有一种父类。
这样就是继承关系呈树状，体现了java简朴性。

子类只能继承在父类中可以访问属性和办法（事实上父类中私有属性和办法也会被继承但子类中无法访问罢了）。

访问控制修饰符（可以修饰属性和办法）
private修饰符，表达只有本类内部可以访问。
default修饰符，办法不加修饰符，会默以为default，表达在同一种包中可以访问，父子类在同一包中，子类可以继承父类相应内容。（可以修饰类）
protected（保护）修饰符，表达同一包中可以访问，不同包子类也可以访问继承。
public修饰符，表达公开，在任何地方都可以访问。（可以修饰类）
修饰符权限是由上而下逐渐变宽。

继承意义
在于子类可以在父类基本之上对父类功能进行发展,继承可以使系统耦合性减少，也就是使对象间联系便松散，使多类对象间联系用其父类对象代替。
注意：构造办法不能被继承。
父类属性及办法拟定
要从子类角度来看子类间共性，当所有子类均有这个属性时，就应当考虑与否该放在父类中，办法也是如此，办法可以被看作是对象行为，而类办法这时这一类对象所共有行为，因此也应当在办法拟定期注意是不是所有子类型中都需要有这种办法，并且会依照不同类型行为方式也不同才可以覆盖着个办法。

java中办法覆盖

子类中有和父类中可访问（可继承到子类）同名同返回类型同参数表办法，就会覆盖从父类继承来办法。

注意：在jdk1.4此前规定办法覆盖时，需要办法返回值，参数表，办法名必要严格相似，而在jdk1.5中办法覆盖，子类中覆盖办法返回值可以是父类中被覆盖办法返回值类型子类型。

注意：子类办法覆盖父类办法时，办法修饰符要么相似，要么子类中办法修饰符表达访问权限要宽于父类。父类中私有办法，不能被继承到子类，就是说子类中虽然将其覆盖了也不会有多态。

覆盖意义：对从父类中继承办法发展。

注意：父子类中有同名属性不叫子类覆盖父类属性，叫做属性遮盖（shadow）。

当构造有继承关系对象环节
1，递归构造父类对象
2，分派空间
3，初始化本类实例变量（属性）
4，调用本类构造办法

注意：子类对象中其实包括着父类对象，也就是父类对象加上子类对象，才是完整子类对象实例。

super核心字
super()，表达在子类构造办法中调用父类构造办法（可以通过这种办法在子类构造办法中初始化父类中属性），super()也只能出当前构造办法第一句上.super(),在子类构造方中指明构造父类时调用哪一种父类构造办法构造父类。
super,这里所示是一种父类对象，可以通过super来使用父类中可以访问办法（可以在父类中定义setXxx()，getXxx()办法来访问父类中私有属性），super可以屏蔽父子类中同名属性冲突。

注意：在写类时候，一定要写默认无参构造办法，如果一种构造办法第一句既不是this(),也不是super()时，那么就会在这里隐含调用她父类无参构造办法，即隐具有super()。

少覆盖原则：
既子类应当尽量少覆盖父类办法，如果覆盖了父类大多数办法，那就应当考虑与否应当有继承关系

java中多态（以子类覆盖了父类办法为前提）

多态，把子类对象主观看作是其父类型对象，那么父类型就可以是诸各种类型。

多态，编译时多态（办法重载）
　　　运营时多态（多态）
编译时类型，也就是可以被看作类型，主观认定。
运营时类型，也就是实际对象实例类型，客观不可变化（也是被看作类型子类型）

对于一种对象来说，在对象产生时，运营时类型就已经拟定不会再变化，编译时类型可以和运营时类型不同。在对象变量声明时可以拟定其运营时类型，但是编译时类型对象变量背后所指向运营时类型则可以是其本类型或者是其子类型。

多态三特性
1，对象实例拟定则不可变化（客观不可变化）
2，只能调用编译时类型所定义办法。
3，运营时会依照运营时类型去调用相应类型中定义办法。

多态意义：在需要使用一类对象共性时，可以用多来屏蔽掉其子类中差别。

注意：类属性是没有多态，只会依照编译时类型访问。只有子类覆盖了父类办法，且把子类对象党作父类类型来看时才会有多态。要注意区别子类中办法重载。对于办法重载，则是会使用编译时类型来进行相应办法调用。
两种复用

1，白箱复用，也就是继承复用，父类中可以被子类访问到就可以被继承，这样会有些不需要内容被继承下来，因此这种方式不太好。
2，黑箱复用，也叫组合复用，也就是把要复用代码类对象作为本类中一种属性，然后再通过办法委托来实现由选取复用，办法委托就是在本类办法内部通过该类对象调用要使用类办法。

注意：尽量用组合复用代替继承复用。

多态使用
多态用于参数，可以在办法参数中传入其父类类型，在运营时会依照实际运营时类型来在办法中进行相应操作。
多态用于返回值，可以在办法返回值类型上是用其实际返回值父类型，在有效期返回值时也不比关怀其实际类型。

多态可以使代码变得更通用，以适应需求变化。也就是定义在父类中办法，可以在子类中有不同实现将其覆盖，在为父类型对象变量赋值相应需要功能子类对象实例。

java中修饰符

static 表达静态，它可以修饰属性，办法和代码块。

1，static修饰属性（类变量），那么这个属性就可以用类名.属性名来访问，也就是使这个属性成为本类类变量，为本类对象所共有。这个属性就是全类公有。（共有类变量与对象无关，只和类关于）。

类加载过程，类自身也是保存在文献中（字节码文献保存着类信息），java会通过I/O流把类文献（字节码文献）读入JVM（java虚拟机），这个过程成为类加载.JVM（java虚拟机）会通过类途径（CLASSPATH）来找字节码文献。

类变量，会在加载时自动初始化，初始化规则和实例变量相似。

注意：类中实例变量是在创立对象时被初始化，被static修饰属性，也就是类变量，是在类加载时被创立并进行初始化，类加载过程是进行一次。也就是类变量只会被创立一次。

2，static修饰办法（静态办法），会使这个办法成为整个类所公有办法，可以用类名。办法名 访问。

注意：static修饰办法，不直接能访问（可以通过组合方式访问）本类中非静态(static)成员（涉及办法和属性），本类非静态（static）办法可以访问本类静态成员（涉及办法和属性），可以调用静态办法。静态办法要慎重使用。在静态办法中不能浮现this核心字。

注意：父类中是静态办法，子类中不能覆盖为非静态办法，在符合覆盖规则前提下，在父子类中，父类中静态办法可以被子类中静态办法覆盖，但是没有多态。（在使用对象调用静态办法时其实是调用编译时类型静态办法）

注意：父子类中，静态办法只能被静态办法覆盖，非静态办法只能被非静态办法覆盖。
java中main办法必要写成static是由于在类加载时无法创立对象，由于静态办法可以不通过对象调用，因此在类main办法所在类加载时就可以通过main办法入口来运营程序。

注意：组合方式，就是需要在办法中创立一种所需要对象，并用这个对象来调用任意所需该对象内容，不会再受只能访问静态约束。

3，static修饰初始代码块，这时这个初始代码块就叫做静态初始代码块，这个代码块只在类加载时被执行一次。可以用静态初始代码块初始化一种类。

动态初始代码块，写在类体中“{}”，这个代码块是在生成对象初始化属性是运营。这种代码块叫动态初始代码块。

类在什么时候会被加载，构造（创立）对象时会加载类，调用类中静态办法或访问静态属性也是会加载这个静态办法真正所在类。在构造子类对象时必会先加载父类，类加载会有延迟加载原则，只有在必要加载时才会加载。

final修饰符，可以修饰变量，办法，类

1，final修饰变量
被fianl修饰变量就会变成常量（常量应当大写），一旦赋值不能变化，（可以在初始化时直接赋值，也可以在构造办法里也可以赋值，只能在这两种办法里二选一，不能不为常量赋值），fianl常量不会有默认初始值，对于直接在初始化是赋值时final修饰符常和static修饰符一起使用。

2，final修饰办法，被final修饰办法将不能被其子类覆盖，保持办法稳定不能被覆盖。
3，final修饰类，被final修饰类将不能被继承。final类中办法也都是final。

注意：final，不能用来修饰构造办法，在父类中如果有常量属性，在子类中使用常量属性时是不会进行父类类加载。静态常量如果其值可以拟定，就不会加载该类，如果不能拟定则会加载该常量所在类。

不变模式：对象一旦创立属性就不会变化。用final修饰属性，也用final修饰类（强不变模式），用final修饰属性（弱不变模式）。
不变模式典型体现：java.lang.String类，不变模式可以实现对象共享（可以用一种对象实例赋值给各种对象变量。）

池化思想，把需要共享数据放在池中（节约空间，共享数据）只有String类可以用“”中字面值创立对象。在String类中，以字面值创立时，会到Java办法空间串池空间中去查找，如果有就返回串池中字符串地址，并把这个地址付给对象变量。如果没有则会在串池里创立一种字符串对象，并返回其地址付购对象变量，当另一种以字面值创立对象时则会重复上述过程。
如果是new在堆空间中创立String类对象，则不会有上述过程。

String类中intern()办法会将在堆空间中创立String类对象中字符串和串池中比对，如果有相似串就返回这个串串池中地址。

不变模式在对于对象进行修改，添加操作是使相称麻烦，她会产生诸多中间垃圾对象。创立和销毁资源开销是相称大。
String类在字符串连接时会先效率很低，就是由于它所产生对象书性是不可以修改，当连接字符串时也就是只能创立新对象。

对于诸多字符串连接，应当使用StringBuffer类，在使用这个类对象来进行字符串连接时就不会有多余中间对象生成，从而优化了效率。

abstract（抽象）修饰符，可以修饰类和办法

1，abstract修饰类，会使这个类成为一种抽象类，这个类将不能生成对象实例，但可以做为对象变量声明类型，也就是编译时类型，抽象类就像当于一类半成品，需要子类继承并覆盖其中抽象办法。

2，abstract修饰办法，会使这个办法变成抽象办法，也就是只有声明（定义）而没有实现，实现某些以"；"代替。需要子类继承实现（覆盖）。

注意：有抽象办法类一定是抽象类。但是抽象类中不一定都是抽象办法，也可以全是详细办法。

abstract修饰符在修饰类时必要放在类名前。

abstract修饰办法就是规定其子类覆盖（实现）这个办法。调用时可以以多态方式调用子类覆盖（实现）后办法，也就是说抽象办法必要在其子类中实现，除非子类自身也是抽象类。

注意：父类是抽象类，其中有抽象办法，那么子类继承父类，并把父类中所有抽象办法都实现（覆盖）了，子类才有创立对象实例能力，否则子类也必要是抽象类。抽象类中可以有构造办法，是子类在构造子类对象时需要调用父类（抽象类）构造办法。

final和abstract，private和abstract，static和abstract，这些是不能放在一起修饰符，由于abstract修饰办法是必要在其子类中实现（覆盖），才干以多态方式调用，以上修饰符在修饰办法时期子类都覆盖不了这个办法，final是不可以覆盖，private是不可以继承到子类，因此也就不能覆盖，static是可以覆盖，但是在调用时会调用编译时类型办法，由于调用是父类办法，而父类办法又是抽象办法，又不可以调用，因此上修饰符不能放在一起。

抽象（abstract）办法代表了某种原则，定义原则，定义功能，在子类中去实现功能（子类继承了父类并需要给出从父类继承抽象办法实现）。
办法一时间想不到怎么被实现，或故意要子类去实现而定义某种原则，这个办法可以被定义为抽象。(abstract)

模板办法模式：用abstract把制定原则和实现原则分开，制定原则就是模板，实现就是按模板原则来实