1.基本结构：
public static void main(String[] args) {
权限修饰符、静态修饰符 返回值类型 方法名 参数
}
2.fload类必须加上F、f否则编译器会当成double
3.final常量，可以先定义在赋值，但只能赋值一次
4.static
static方法：不依赖于任何对象就可以访问，故没有this操作，静态方法中不可访问非静态方法和变量，反之可以。
补充：当然也可以将某个类的实例对象，然后通过该实例对象调用非静态方法
static变量：不可修饰局部变量，同样不需要依托于对象（与C语言不同，static不可限制权限），两个对象对同一个静态成员变量操作，将会操作内存中的同一个地址
5.String：
字符串常用方法：indexOf()该字符串第一次出现的位置
lastIndexOf（）该字符串第一次出现的位置
charAt（）指定位置的字符
subString（1，3）截取字符串
trim（）去除前导空格和尾部空格
replace（”A”，”B"）替换字符串
startsWith（）endsWith（）是否是这个前缀或者后缀
compareTo（）按照字典顺序比较两个字符串，基于Unicode值
例：
String str1 = "test11";
String str2 = "test22";
str2.compareTo(str1)返回“1”，相反“-1”，相同则“0”
split（”,”,3）按照指定字符和次数限制分割字符串
equals（）对比两个对象（必须是地址和内容全部相同）
例：String s1 = new String("jianghong");
String s3 = new String("jianghong");
String s2 = "jianghong";
String s4 = "jianghong";
那么s2=s4,s1!=s3.解释：new 出来的对象会调用String的构造函数，同时在堆里和对象池里各创建一个对象。但直接赋值会首先在对象池查找是否有相同的字符串，有的话则将地址指向这个字符。
例：
String a = "1";
String b = "2";
String c = "12";
String d = "1"+"2";
String e = a+b;
如果 final a final b 那么c和e‘是否相等
c = d ,c != e ,c=e'
解释：取决于在编译期间是否能知道它实际的内容。
6.数组：java.util.Arrays
排序：Arrays.sort(arr)
搜索：Arrays.binarySearch(arr,0,2,5);
冒泡排序、选择排序、反转排序（有序）
7.类
extends 继承与某个类
class SubClass extends SuperClass{
//构造方法调用父类构造方法
public Subclass(String name){
super (name)
}
}
implement 实现某个接口(interface支持被继承，类中支持多接口实现)
//定义了一个接口Flyer
interface Flyer
{
void fly ();
int ID = 1;
}
public class Animal extends Person implements Flyer,Runner{
@Override
public void fly() {
}
int j = Flyer.ID;
}
构造方法的调用顺序为先顶级再父类再自身
8.权限修饰符 java
| 包位置 |private|protected|public
| -------------|-------------| -----|
| 本类 |可见 | 不可见| 不可见 |
| 同包其他类或子类 |不可见 | 可见 | 可见 |
| 其它包的类或者子类 | 不可见 | 不可见 | 可见 |
类的成员不写访问修饰时默认为default。默认对于同一个包中的其他类相当于公开（public），对于不是同一个包中的其他类相当于私有（private）。受保护（protected）对子类相当于公开，对不是同一包中的没有父子关系的类相当于私有
9.java内存回收（对象的销毁）当超出作用范围或者被赋为null的时候。不足之处为只能回收由new创建的对象，那么就要写方法finalize(),调用这个方法，手动将对象销毁（null）。但是当Java内存爆炸用完的时候
10.关于计算机编码基础
原码：
如果机器字长为n，那么一个数的原码就是用一个n位的二进制数，其中最高位为符号位：正数为0，负数为1。剩下的n-1位表示概数的绝对值。
例如： X=+101011 , [X]原= 00101011 X=-101011 , [X]原= 10101011
位数不够的用0补全。
PS：正数的原、反、补码都一样：0的原码跟反码都有两个，因为这里0被分为+0和-0。
反码：
反码就是在原码的基础上，符号位不变其他位按位取反(就是0变1，1变0)就可以了。
例如：X=-101011 , [X]原= 10101011 ，[X]反=11010100
补码：
补码也非常的简单就是在反码的基础上按照正常的加法运算加1。
例如：X=-101011 , [X]原= 10101011 ，[X]反=11010100，[X]补=11010101
PS：0的补码是唯一的，如果机器字长为8那么[0]补=00000000。
移码：
移码最简单了，不管正负数，只要将其补码的符号位取反即可。
例如：X=-101011 , [X]原= 10101011 ，[X]反=11010100，[X]补=11010101，[X]移=01010101
11.对象类型转型
向上转型：SuperClass super = new SubClass();即，将子类的对象赋值给父类。
例：假设SuperClass有个方法test(SuperClass class)，这样如果根据子类对象的不同在父类的方法中，进行不同的处理，这就是多态的思想。
向下转型：将父类对象赋值给子类，可能会出现对象成员的错误，需要使用显示类型转换（SuperClass）
instanceof：判断某个对象是否为某一个类的一个实例
12.抽象类：使用abstract修饰，抽象类不能拥有实例化的对象，但可以通过继承和多态实现方法。抽象方法本身没有方法体，没有实际意义
13.java 中使用import可以指定某个包中的所有类，如：import com.test.jianghong.*，import不仅能导入类，也可以导入静态成员，如import：static java.lang.Math.max;
14.集合类 map、list、set
迭代器iterator(),
Collection<String> list =new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
Iterator <String> it = list.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
```
15.I/O输入输出
所有输入流类都是抽象类InoutStream或Reader的子类。所有输出都是OutputStream或Writer的子类
InputStream是用来处理字节的，不适合处理字符文本（字符采用Unicode编码，双字节），而Reader则能处理字符流
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class StandardInputOutput {
public static void main(String args[]) {
String s;
// 创建缓冲区阅读器从键盘逐行读入数据
InputStreamReader ir = new InputStreamReader(System.in);
BufferedReader in = new BufferedReader(ir);
System.out.println("Unix系统: ctrl-d 或 ctrl-c 退出"
+ "\nWindows系统: ctrl-z 退出");
try {
// 读一行数据，并标准输出至显示器
s = in.readLine();
// readLine()方法运行时若发生I/O错误，将抛出IOException异常
while (s != null) {
System.out.println("Read: " + s);
s = in.readLine();
}
// 关闭缓冲阅读器
in.close();
} catch (IOException e) { // Catch any IO exceptions.
e.printStackTrace();
}
}
}
16.class类与java的反射
通过getClass、getMethods等可以返回java对象的描述信息。如果去类名，类的构造方法，类中的成员等
17.Java中的枚举类enum，该类可定义枚举常量，也可以自定构造方法定义带参数的枚举类型成员
enum Constants2{
Constants_A("test1"),Constants_B("test2");
private String description;
private Constants2(String description){
this.description = description;
};
private String getDescription(){
return description;
}
}
public static void main (String []args ){
for (int i = 0; i <Constants2.values().length ; i++) {
out.println("枚举成员变量" + Constants2.values()[i]+"输入" + Constants2.values()[i].getDescription());
}
}
补充：枚举类也可以实现接口
interface d {
public String getDescription();
}
public enum Constant3 implements d{
Constants_A{
public String getDescription(){
return ("test3");
}
}
}
18.泛型类，使用格式为Class<T>,这个类不规定自身类型，在使用的时候自动转化为需要的类型
public class Tclass <T>{
private T[] array;
public void SetT(T[] array){
this.array = array;
}
public T[] getT(){
return array;
}
public static void main(String[] args) {
Tclass <String >tClass = new Tclass<String >();
String[] array = {"var1","var2","var3"};
tClass.SetT(array);
for (String a: tClass.getT()
) {
System.out.println("数组泛型类 "+a);
}
//通配符？先不确定类型，在实际使用的时候再确定类型
Tclass<? extends List> a = null;
a = new Tclass<ArrayList>();
a = new Tclass<LinkedList>();
}
}
