可参考 《阿里云java开发规范》
共有 8 种基本类型：
strictfp关键字：处理a * b / c，jvm 默认先截断 a * b，再除以 c，而加了这个关键字后，丢给底层 intel去处理中间的截断，这样就更加精确。
enum 关键字：
参考博客
public class hello3 {
enum Size {SMALL, MEDIUM, LARGE};
public static void main(String args[]) {
Size s = Size.SMALL;
System.out.println(s.toString()); // output: SMALL
System.out.println(s.ordinal()); // 0
}
}
String 关键字
String Buffer 和 String Builder
StringBuffer 和 StringBuilder 长度可变
多线程环境下，StringBuffer 线程安全， StringBuilder 线程不安全，StringBuffer通过对 append 方法加锁来达到线程安全的，builder没有加锁。
单线程使用时，StringBuilder 速度快
Arrays 好用的 API
在一个系统中，类应该是一个名词，方法应该是一个动词
其实有时候更多是结合业务背景的语义来判断二者是什么关系，直接通过代码不好判断
class Car {
public static void run() {
System.out.println("汽车在跑");
}
}
class Driver {
public void driver(Car car) {
// 使用形参方式发生依赖关系
car.run();
}
public void driver() {
// 使用局部变量发生依赖关系
Car car = new Car();
car.run();
}
public void driver1() {
// 使用静态方法发生依赖关系
Car.run();
}
}
在 java 中对象的拷贝必须使用clone()方法才能获取完整的拷贝
this 关键字可以理解为方法的隐式参数，可以区别方法中的局部变量和类的成员变量；也可以理解为是类对象的实例；this关键字还可以作为该类的另一个构造器
假设类中的成员变量含有引用型变量 a，那么 a 的 getter 应该返回 a.clone()。这里涉及到了对象的深拷贝和浅拷贝：
深拷贝：一个对象中引用型成员变量内的属性也拷贝，换句话说深层次的属性成了两份
浅拷贝：仅拷贝引用，换句话说对象中引用型成员变量的属性只有一份
/*
* 一个简单的 A 类有一个简单的属性int attrA，还有操作这个属性的 getter 和 setter
* 一个简单的 B 类有两个属性，一个属性是 A a，另一个属性是 int attrB，以及操作这两个属性的 getter 和 setter
* 根据封装性，规定当修改一个属性的时候必须通过类的 getter 和 setter 修改，所以当返回一个引用类型的时候，应该返回它的副本
*
*/
class A {
private int attrA;
/* 省略 attrA 的 getter 和 setter */
public Object clone() {
A a = new A(this.attrA);
return a;
}
}
class B {
private A a;
private int attrB;
/* 省略 a 的 setter 和 attrB 的gtter、setter */
public A getA() {
return (A) a.clone();
}
public Object clone() {
B b = new B(this.a, this.attrB);
return b;
}
}
public class hello3 {
public static void main(String args[]) {
A testA = new A(1);
B testB = new B(testA, 2);
A myA = testB.getA();
myA.setAttrA(11); // 如果 A 没有 clone方法，就破坏了封装性。因为如果没有调用testB的setA()方法就改变了数据，这是不合法的。
System.out.println(testB.getA().getAttrA()); // output: 1
System.out.println(myA.getAttrA()); // output: 11
}
}
int main(void){
int a = 1;
test(a);
printf("out: %d\n", a); // output: 3
}
void test(int &p){ // p 相当于 a 的一个别名，对形参的更改会引起实参本身的变化
p = p+2;
printf("in: %d\n", p); // output: 3
}
void testPointer(int *p){ // 指针传递，对形参本身的更改不会引起实参的变化，但是对指向内容的更改会引起变化
}
class A {
int a, b;
public A(int a) {
this(a, 2); /// 调用另一个构造器，给另一个构造器提供默认值
}
public A(int a, int b) {
this.a = a;
this.b = b;
}
}
除了基本的//和/**/之外应该掌握文档注释
javadoc对注释生成文档，可以使用标记：@author，@version,@return，@params，@see等进行注释
public class hello3 {
/**
* @author 陈
* @version 1.0
*
*/
/**
* hello 方法的简述
* <p> hello 方的详细说明 </p>
* @param str 问候语
* @param name 名字
* @return return 返回格式化字符串
*/
public String hello(String str, String name) {
return str+"," + name +"!";
}
}
对象方法的调用过程与动态绑定：
方法表->方法签名->动态绑定
内联：如果父类方法很短比如，e.getName()，那么虚拟机会优化为 e.name 直接读取，这样就可以加快速度。
// Person 是一个抽象类，Student 是继承 Person 的非抽象类
Person p = new Student(); // p 是一个抽象变量，指向子类对象
总的来说就是动态获取类信息，例如在 android 项目开发中，比如有三个Acitivity类，A1，A2，A3，此时运行中的 Activity 可能是 A1 或者 A2，如果 A3 中有两个方法，method1 和 method2，如果是A1->A3，那么执行 method1；如果是 A2->A3，那么执行 method2。一个简单的策略是可以通过Intent进行通信，但是如果有很多 Activity，不同 Activity 要分发不同的 Intent 到 A3 中执行不同的 method，此时通过 Intent 消息通信就比较麻烦。这时就可以利用反射机制，动态的获取当前运行态的 Activity 类的信息分发到 method 中，无疑比 Intent 消息传递来的更加简便。
...
try {
Class obj = Class.forName(personName); // Class.forName() 根据字符串拿到 class
Method method = obj.getMethod(methodName, null); // getMethod() 引用方法
method.invoke(obj.newInstance(), null); // invoke 使用实例对象的方法
} catch (Exception e) {
e.printStackTrace();
}
...
标记接口是指仅有一个名字，没有内容的接口
略
Object默认的是clone()方法是protected的浅拷贝，子类应该实现Cloneable接口，自定义public的深拷贝clone()方法，让任何人都能调用这个方法，克隆这个对象，而不仅仅是子类能调用。
为什么要把Object的clone()方法设置成protected仅有子类能访问？
Class Employee implements Cloneable{
// 提升 clone() 权限
public Employee clone() throws CloneNotSupportedException{
return (Employee) supper.clone();
}
}
内部类主要分为普通内部类**（成员内部类）、局部内部类（方法内部类）、匿名内部类、嵌套内部类（静态内部类）**。
非静态内部类中不能定义静态成员，静态内部类不能访问外部类普通成员变量（非静态成员）。
/*第一段代码：普通的用法*/
interface A{
int add(int a, int b);
}
public class hello3 {
public static void main(String args[]) {
A a = (param1, param2)->{return param1+param2;};
System.out.println(a.add(1, 1)); // output: 2
}
}
/*第二段测试代码：实现runable接口，从下面的代码可以看出runable接口实际上是一个接口变量*/
...
new Thread(()->{System.out.println("do something");}).start();
...
/*第三段代码：函数参数是接口变量*/
interface A{
int add(int a, int b);
}
public class hello3 {
public static void main(String args[]) {
int param1 = 1;
int param2 = 1;
test((int i, int j)->{ // 怎么感觉这么鸡肋
return i+j;
}, param1, param2);
}
// a 是一个接口变量
public static void test(A a, int param1, int param2) {
System.out.println(a.add(param1, param2));
}
}
/*第四段代码： 不用 lambda 版本，用匿名内部类*/
...
test(new A() {
@Override
public int add(int a, int b) {
return a+b;
}
}, param1, param2);
...
①静态代理和目标实现同样的接口，当目标改动的时候，静态代理也要改变。当有多个静态代理的时候，修改起来比较麻烦，所以出现了动态代理。
②感觉动态代理就是要在运行时创建类对象，因为创建了类对象，只能知道它的信息，只能通过Method类获取方法，在类中通过method.invoke()去调用被代理的对象的方法，然后自己在method前后添加逻辑即可。
/*javassist框架实现的代码*/
import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtMethod;
import javassist.CtNewMethod;
public class MyGenerator {
public static void main(String[] args) throws Exception {
ClassPool pool = ClassPool.getDefault();
// 创建 Programmer 类
CtClass cc= pool.makeClass("com.samples.Programmer");
// 定义方法
CtMethod method = CtNewMethod.make("public void code(){}", cc);
// 插入方法代码
method.insertBefore("System.out.println(\"I'm a Programmer,Just Coding.....\");");
cc.addMethod(method);
// 保存生成的字节码
cc.writeFile("d://temp");
}
}
/*jdk代理核心api*/
static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h )
/* client input: jar options retFileName targetFile1 tartgetFile2 */
>> jar cvf first.jar picture.png
要记住几个事实：类型消除、限定类型、自动强制转换、桥方法
虚拟机中没有泛型，只有普通的类和方法；（类型消除）
所有的类型参数（T,U等)都用它们的限定类型替换；（限定类型）
为保持类型安全性，会加入自动强制转换（自动强制转换）
桥方法是因为子类方法未覆盖住父类方法，多态灾难；（桥方法）
...
class<T, B, C, D> test{ // 可以有多个类型变量
...
}
// 注意类的T和泛型方法的T没关系
class Test<T>{
...
public static <T extends Father> T genericMethod(T a){
return a;
}
...
}
interface MyInterface1{
...
}
class MyClass implements MyInterface1, MyInterface2{
...
}
// 这里的 T 只能是 MyClass 类
class FirstGeneric<T extends MyInterface1 & MyInterface2>{
...
}
实际上类型擦除后，程序员是否正确使用泛型类，在编译前，IDE 就会自动检查，真方便
class Test<T>{ // 类型擦除为原始类型
T attr;
}
/* <=> */
class Test{
Object attr; // 默认为 Object
}
class Test<T extends Father & Mother>{ // 类型擦除为离得近的限定类型 Father，而mother不管她
T attr;
}
/* <=> */
class Test{
Father attr; // 此时是Father
}
class A{ // 单独的具体类
public void noMethod(){
System.out.println("run noMethod");
}
}
class Father{ // 泛型限定父类
public void method(){
System.out.println("run FatherMethod");
}
}
class Child extends Father{ // 继承了限定类的具体类
public void childMethod(){
System.out.println("run ChildMethod");
}
}
class Test<T extends Father>{ // 泛型类
public void testMethod(T t){
t.method(); // 调用父类已经实现的方法，并且具体类是父类的子类才会成功
}
public void testNoMethod(T t){
t.noMethod(); // 因为父类没有实现 noMethod()，所以即使传进来的 T 类已经实现了 noMethod() , 依然会报错
}
public void testChildMethod(T t){
t.childMethod(); // 父类没有实现 childMethod
}
}
public class hello{ // 主类进行测试工作
public static void main(String args[]){
Test<A> t = new Test<>();
A a = new A(); // 单独的具体类
t.testMethod(a); // 失败，限定类实现，但是具体类A非子类
t.testNoMethod(a); // 失败，限定类未实现，且具体类A非子类
Test<Child> childT = new Test<>();
Child child = new Child(); // 限定类子类
childT.testMethod(child); // 成功，满足两个条件
childT.testChildMethod(child); // 失败，限定类未实现
}
}
class Test<T>{
private T attr;
public Test(T attr){ // 构造器
this.attr = attr;
}
public T getAttr(){ // getter 方法返回一个 T 类型
return this.attr;
}
}
public class hello{
public static void main(String args[]){
Test<Integer> test = new Test<>(123);
Integer myInt = test.getAttr(); // <=> test.getAttr()先返回Object，然后Integer强制转换： Integer myInt = (Integer) test.getAttr();
}
}
class Pair<T>{
private T first=null;
private T second=null;
public Pair(T fir,T sec){
this.first=fir;
this.second=sec;
}
public T getFirst(){
return this.first;
}
public T getSecond(){
return this.second;
}
public void setFirst(T fir){
this.first=fir;
}
}
...
Pair<String> pair1=new Pair("string",1); // 构造出来没问题，但是在调用 getSecond()出错
Pair<String> pair2=new Pair<String>("string",1) // 编译器直接出错
...
class Pair<T>{
public void setFirst(T fir){...}
public T getFirst(){...};
}
// 讨论 setter
class SonPair extends Pair<String>{
public void setFirst(String fir){...} // 此时由于类型擦除现象会有两个 setter，无法覆盖父类 setter
public void setFirst(Object fir){ // jvm编译期间自动生成桥方法，程序员不可见
setFirst((String) fir) // 子类的setter，且强制转换参数
}
}
// 讨论 getter
class DaughterPair extends Pair<String>{
public String getFirst(){...}; // 仍然有两个 getter
public Object getFirst(){...}// 会出现神奇的事情，桥方法会出现签名一样的方法，虽然程序员不能编写签名一样的方法，但是jvm是通过返回值和方法签名唯一确定一个方法，所以它自己可以生成这种签名一样的方法
}
class Pair<T>{
...
private static T a ; // 禁止
private static T get(){...}; // 禁止
private static set(T t){...}; // 禁止
...
}
...
Pair<String>[] stringPairs=new Pair<String>[10]; // 禁止
...
...
public static <T> Pair<T> makePair(Class<T> cl){
try{
return new Pair<T>(cl.newInstance(), cl.newInstance());
}catch(Exception e){
return null;
}
}
/*
等价于下面这种写法，但是下面这种写法不支持
<=>
public Pair(){
fir = new T();
sec = new T()
};
*/
...
...
/* 调用方法 */
Pair<String> p = Pair.makePair(String.class);
...
如下问题 Test 不是 Test 的子类，这就引出了通配符问题。
class Father{
...
}
class Son extends Father{
...
}
class Test<T>{
...
}
...
Test<Son> 不是 Test<Father> 的子类
...
感觉书上的写的看着好累，但是确实经典，但是解释不全面
参考博客1，总结得很到位
参考博客2，讲解得很仔细
参考博客3，讲到了协变，逆变，不变的概念
参考博客4，解释的很完美啊，和自己的理解也特别符合，和我的用例也相当符合
/*
* 下面代码中Child1和Child2是Father的儿子，A是泛型类
* Test类中有两个method：method1测试泛型方法，method2测试通配符方法
* 可以看见method1中，只能是Child1，而method2中还可以其他孩子
* 因此通配符方法比泛型方法更加通用
*/
class Father {
}
class Child1 extends Father{
}
class Child2 extends Father{
}
class A<T>{ // 泛型类
}
class Test{ // 测试类
public void method1(A<Child1> a) { // 泛型方法，只能是Child1
System.out.println("run method1");
}
public void method2(A<? extends Father> a) { // 通配符方法，可以是Father的所有孩子
System.out.println("run method2");
}
}
public class hello2 { // 主类进行测试工作
public static void main(String args[]) {
A<Child1> aChild1 = new A<Child1>();
A<Child2> aChild2 = new A<Child2>();
Test test = new Test();
test.method1(aChild1);
//test.method1(aChild2): // 其他孩子就报错了
test.method2(aChild1);
test.method2(aChild2);
}
}
子类型限定 <? extends Father>：“in” 类型生产者，可以用getter提供返回值，但是无法使用setter消费
超类型限定 <? supper T>：“out"类型消费者，可以用setter消费值，但是无法使用getter生产
/* 无法使用setter和getter的解释 */
class Father {
}
class Child1 extends Father{
}
class Child2 extends Father{
}
class GrandChild extends Child1{ // Father的孙子，Child1的儿子
}
class GrandGrandChild extends GrandChild{ // 曾孙子
}
class A<T>{ // 泛型类
private T t;
public A(T t) {
this.t = t;
}
public T get() {
return t;
}
public void set(T t) {
this.t = t;
}
}
class Test{ // 测试类
}
public class hello2 { // 主类进行测试工作
public static void main(String args[]) {
Father father = new Father();
Child1 child1 = new Child1();
Child2 child2 = new Child2();
GrandChild grandChild = new GrandChild();
A<Father> aFather = new A<Father>(father);
A<Child1> aChild1 = new A<Child1>(child1);
A<Child2> aChild2 = new A<Child2>(child2);
A<GrandChild> aGrandChild = new A<GrandChild>(grandChild);
A<? extends Father> aChild = aChild1; // ? 是子孙，它的 getter 没问题，但是 setter 报错
/*
* getter:? extends Father get(){...}
* setter: void set(? extends Father){...}
*/
Father fRet = aChild.get(); // getter 返回一个不确定的子类对象，编译器用capture#1占位符来代替这个不确定的子类，具体是什么不知道，只能用父类引用去接它
// aChild.set(child2); // 报错，因为必须是 capture#1 类型才允许插入，但是Father的子类无法匹配这个类型，所以就直接插不进去
A<? super GrandChild> bGrand = aGrandChild; // ? 是祖先，它的 getter 报错，setter 没问题
/*
* getter: ? super GrandChild get(){...}
* setter: void set(? super GrandChild){...}
*
*/
// Object obj = bGrand.get(); // 返回的是一个 capture#1 占位符父类对象，没有东西可以接它
bGrand.set(grandChild); // 参数是grandChild的所有父类引用占位符capture#1，所以设置子类没问题
bGrand.set(new GrandGrandChild()); // 设置了一个子孙对象
}
}
无限定通配符<?>：<? extends Object>，getter只能返回给Object，而setter不能使用
PECS 原则：producer extends consumer supper。注意:<? extends Father>，jvm底层理解为占位符capture#2，getter时候返回匹配的所有下界对象，只能用上面的父类去引用这个对象；而<? super Child>，也是理解为占位符，setter的时候匹配所有上界引用，只能用子类对象给它。总之，记住一句话，父类可以引用子类对象，子类不能引用父类对象。
通配符的捕获：因为通配符表示一个类型的范围，当通配符在运行的时候是一个确定的类型的时候，就可以用helper类捕获。