权限关键字：

public：可以被所有其他类所访问,不同的包

protected：当前类的成员、同一个包中、不同包中对子类可见父类protected，继承类

default：同一包中的类可以访问，声明时没有加修饰符，认为是friendly。同一个包

private：只能被自己访问和修改

都可以修饰类中的成员变量和方法，但是只有public和友好型可以修饰类

 

（封装、抽象、多态、继承）

封装：隐藏内部实现过程，给调用者提供一个访问结果的方法，如Javabean的setter和getter。

 

抽象：类中的方法：（为了被继承而生，然后重写方法，必须是public或者protected）

1. 抽象方法，没有方法体；

2. 具体方法，有方法体。

接口中的方法：

1.方法会被隐式地指定为public abstract方法且只能是public abstract方法（）；

 

接口：对修改关闭，对扩展开放

变量默认为public static final；

            方法默认为public abstract；

 

Static:

1、修饰内部类，变成静态内部类，修饰普通类，初始化就加载，浪费内存；

2、修饰成员变量，类加载时就创建，共享数据；(静态变量是定义在类中，方法体外面的)

3、修饰方法，通过类名直接访问；

4、静态代码块，防止每次都要new一个对象;

5、静态导包，不用输入类名使用方法和变量，1.5。

Final:

1、修饰类，不可以被继承，不能被修改，例如String、Integer、Math等；

2、修饰方法，子类不可重写，锁定方法，隐性如private；

3、修饰实例变量，引用不可改变，内容可以改变；

4、可修饰局部变量和方法参数，（修饰后只有匿名内部类和局部内部类才能访问final修饰的参数和变量）

transient:

修饰实例变量，保证不被序列化。

native：

关键字说明其修饰的方法是一个原生态方法，方法对应的实现不是在当前文件，而是在用其他语言（如C和C++）实现的文件中，如操作系统。

Java语言本身不能对操作系统底层进行访问和操作，但是可以通过JNI接口调用其他语言来实现对底层的访问

普通方法用native修饰可以没有方法体。

Volatile：

1、保证被修饰的变量在多线程之间的可见性，即其他线程可以立即得知一个线程的改变。它是java.util.concurrent包的核心；

2、CPU缓存的出现主要是为了解决CPU运算速度与内存读写速度不匹配的矛盾；

 

声明时为成员变量赋值，那么你一创建对象，这个赋值就进行，而且先于构造器执行

使用构造函数给成员变量赋值，每次调用时可以传递不同参数。可维护性强。

执行父类静态代码 执行子类静态代码：

static修饰的属性的初始化在编译期（类加载的时候），初始化后能改变

static和“this、super”势不两立，static跟具体对象无关，而this、super正好跟具体对象有关

Java的规定：子类继承父类，子类的构造方法必须调用super（）即父类的构造方法，而且必须放在构造方法的第一行。

初始化父类成员变量（我们常说的赋值语句），普通代码块。

初始化父类构造函数

初始化子类成员变量，普通代码块。

初始化子类构造函数

总结：假如我们要在一个类中的所有对象间共享某种数据，不如将该数据声明为静态成员变量。假如你不想让该类之外的所有函数都可以访问该数据，可将其定义为私有成员，那么就只有该类的公有成员才可以访问它了。访问的前提是必须创建一个属于该类的对象。

静态成员变量和静态方法的优势是可以不用创建对象就调用。变量不想被外部类调用，可私有化。

内存分配: 

桟:存储对象的引用，局部变量的基本数据类型，速度快，自动销毁;

堆:存储new出来的对象，数组，成员变量的基本数据类型;

常量池:属于方法区，存储final的变量和方法;

静态域:属于方法区，存储static的变量和方法;

方法区:存储二进制class字节码。

 

Demo demo=new Demo();  

 这一条语句，其实包括了四个动作：

     1）右边的“new Demo”，是以Demo类为模板，在堆空间里创建一个Demo对象。

     2）末尾的()意味着，在对象创建后，立即调用Demo类的构造函数，对刚生成的对象进行初始化。 

     3）左边的“Demo demo”创建了一个Demo类引用变量，它存放在栈空间中。也就是用来指向Demo对象的对象引用。 

     4）“=”操作符使对象引用指向刚创建的那个Demo对象。

 

Cloneable接口和Object的clone()方法：

在Java中表示的将等号右边的引用赋值给等号左边的引用，二者指向的还是同一块内存

1、Cloneable接口（一个空接口，经典的标示接口，如同序列化，告诉jvm。使用native方法，浅克隆）

三句话总结：

（1）此类实现了Cloneable接口，以指示Object的clone()方法可以合法地对该类实例进行按字段复制

（2）如果在没有实现Cloneable接口的实例上调用Object的clone()方法，则会导致抛出CloneNotSupporteddException

（3）按照惯例，实现此接口的类应该使用公共方法重写Object的clone()方法，Object的clone()方法是一个受保护的方法

2、Object的clone()方法

创建并返回此对象的一个副本。对于任何对象x，表达式：

（1）x.clone() != x为true

（2）x.clone().getClass() == x.getClass()为true

（3）x.clone().equals(x)一般情况下为true，但这并不是必须要满足的要求

1 2 3 4 5 6 7 8

Stutend stutend2 = (Stutend) stutend1.clone(); class  Stutend  implements  Cloneable{      private  String name;      private  int  age;      public  Object clone()  throws  CloneNotSupportedException      {          return  super .clone();      }

 

 

 

StringBuffer和StringBuilder:

字符串变量（Synchronized，即线程安全），操作方法都为同步synchronized方法。

如果想转成String类型，可以调用StringBuffer的toString()方法。

append方法始终将这些字符添加到缓冲区的末端；

insert方法则在指定的点添加字符。

1、String s = "a" + "b" + "c";相当于StringBuffer sf = new StringBuilder("a").append("b").append("c");(速度快）

2、但要注意的是，如果拼接的字符串来自另外的String对象的话，Java Compiler就不会自动转换了，速度也就慢了。

String a = "a";

String b = "b";

String c = "c";

String d = a + b + c;(速度慢）

 

如果使用少量的字符串操作，使用String；

如果频繁的对大量字符串进行操作，则使用

1：全局变量或者需要多线程支持则使用StringBuffer；（毕竟需要同步字符串的情况真的不多，多个线程操作一个list，增加数据。）

2：局部变量或者单线程不涉及线程安全则使有StringBuilder。

 

在子类中this和super区别：

在继承的子类中，没重写那super.add() 和this.add() 都是调的父类的方法， 没什么区别，

如果重写了this.add()就默认调本类的方法，super就默认调父类的方法，

this.name = name ,解决成员变量与参数重名问题。

 

打包文件夹：

jar -cvf x.jar *

javac -encoding utf-8 test.java

 

String的hashCode:

1、计算采用素数31，使用31的原因可能是为了更好的分配hash地址，并且31只占用5bits，减少相同的hashCode值，方便快速查找；

2、实现了equals，一定要实现hashCode. equals相等，hashCode一定相等。

 

System.load(String filename)和System.loadLibrary(String libname)

1、System.load文件名参数必须是完整的路径名；

2、System.loadLibrary指系统库。