java入门级知识点回顾

jdk包含jre，jre包含jvm
裸机安装操作系统，得到虚拟计算机
虚拟计算机安装jdk，进而得到java虚拟机——jvm
jvm本身不是跨平台的，java提供了不同操作系统下的jvm版本
java文件经过java编译器处理成jvm能识别的字节码文件（.class），jvm会将字节码文件转化成对应操作系统的本地机器码，最终操作系统运行机器码。
java内存主要4块：
栈内存——stack：存放基本类型数据 和 对象名（引用，包括数组名）
堆内存——heap：存放对象实体（包括数组的实体）
数据区：静态变量和常量
代码区：存储类信息，包括方法代码

方法重载：同名不同参数，返回类型不在考量范围。
方法签名：指方法名+参数

类的字节码被加载到内存时，静态成员就分配了内存空间

类中额外的代码块称为构造代码块，这部分代码，先于构造方法执行。
被static修饰的代码块称为构造代码块，这部分代码，在类加载到内存时就开始执行了。

内部类，他可以直接访问外部类的私有属性或方法

数据结构：栈（Stack）【后进先出】
常用数组存储元素，栈顶指针假设为top，判定空时top=0
进栈，top+1，出栈，top-1，取顶元素，top不变

... MyStack{
	private Integer[] data;
	private int top;
	private int size=50;
	
	...//初始化时top=0
}

数据结构：队列（Queue）插入在队尾，删除在队头(类似于排队走进走廊，但走廊只能容纳n个人)

final 作用于方法时，不允许子类对其进行修改或覆写

final作用于类时，类不允许被继承，其他与普通类没什么不同

abstract抽象类，可包含抽象方法和非抽象方法，不能new创建，可继承，子类完成所以抽象方法则变为正常类。

接口，只能有常量和抽象方法，不能用new创建

面向对象
多少原则：多用组合，少用继承
高低原则：高内聚，低耦合

单例模式：类只创建一个对象

class T{
	private statice T t;
	private T(){};
	public static T getInstance(){
		if(null == t)
			t = new T();
		return t;
	}
}

工厂模式：通过调用方法传入不同的参数，来获得不同的子类对象。
如： A 继承于 抽象类ZM
B继承于 抽象类ZM
通过调用ZM的方法，输入不同参数，能够得到a或者b对象

public abstract class Factory{ ... }
public class Card1 extend Factory{ ... }
public class Card2 extend Factory{ ... }
...main () {
	Factory f1 = new Card1();
	Factory f2 = new Card2();	
}

适配器模式：将原有的接口A 转换成我们希望的另一个接口B
如：写一个B的实现类，给一个方法，方法可传入A接口对象，然后再B的实现类中去调用A的方法，这样B的实现类就具有了A接口的功能了。

Throwable异常类总接口> Error + Exception
Exception下还有子类RuntimeException

泛型：

class Point<T>{
	public T x;
	...
}

通配符：在方法声明中的参数处使用

 public void show(Point<?> p){ ... }

泛型上限： T就必须为后者的子类或当前类

集合框架：
Collection：
Set无序不可重复
List有序可重复
Map：映射关系

Iterator接口可用于遍历Collection集合

windows中目录以反斜杠“\”分割
linux中目录以正斜杠"/"分割

java多线程：继承Thread类 或 实现Runnable接口
继承Thread类:

class MyThread extend Tread{
	...
	public void run(){ ... }
}

...main(){
	MyThread m1 = new MyThread();
	m1.start(); //启动线程
}

实现Runnable接口：

class MyRunnable implements Runnable{
	...
	public void run(){...}
}

...main(){
	MyRunnable m1 = new MyRunnable();
	new Thread(m1).start();//注意这里，接口形式的是以这种方式开启线程的
	...
}

接口的这种调用方法，可以让你同时开启多个线程去操作同一个对象中的私有属性。

 	Ticket t = new Ticket();
 	//假设Ticket是实现了Runnable接口的类,它里面定义了一个私有属性，run方法是操作这个私有属性的。如：假设private count=10,run方法中是 count++;
 	new Thread(t).start();
 	new Thread(t).start();
 	new Thread(t).start();
    //这样，就会有三个线程，他们共同操作这个t对象的私有属性,最终t.count=13;

方法	含义
Thread(String name);	构造器，name为线程名
Thread(Runnable target,String name);	接口形式构造器
start()	启动线程
getName()	获取线程名
currentThread()	返回档期执行的线程
interrupt()	中断线程
sleep(long millis)	让线程休眠

线程
synchronized 同步关键字

实例化Class类的三种方法：

Class<?> c= null;
//第一种
c = "".getClass();
//第二种
c=String.class();
//第三种
c=Class.forName("java.lang.String");

通过class调用类的构造器获取对象，如获取类A的对象

Class<?> c = Class.forName("A");
//1.
A a = (A) c.newInstance();
//2.
Constructor cn = c.getConstructor();
A a = (A)cn.newInstance();
//3.带参构造器
Constructor cn = c.getConstructor(int.class);
A a = (A) constructor.newInstance(100);

还可以通过getField(String name) getMethod(String name)来获取属性或方法，调用反射得来的方法时用invoke();

	Class<?> c = Class.forName("A");
	Method m = c.getMethod("show");
	m.invoke(c.newInstance());

Annotation 使用@interface关键字定义，会被保存到字节码文件中，一般与反射机制结合使用。
@Target 定义了注解的作用级别，比如：方法、接口、属性等等
@Retention设置Annotation的有效范围，如：
SOURCE //保留在程序源码
CLASS //编译到class文件
RUNTIME //执行时加载到jvm