Java基础知识——来源Java书籍，

Java基础知识——来源Java书籍，

 

GC垃圾回收机制在CPU空闲或内存不足时自动进行垃圾回收，程序员无法控制回收的时间与顺序。缺点事影响开销性能，Java虚拟机必须跟踪哪些是有用的对象或者无用的对象。只能回收内存资源，io 数据库资源不能回收。为了更快让垃圾回收机制回收那些对象，可以将引用变量设置为NULL，暗示垃圾回收器回收。垃圾回收是不可预知性的，即使system.gc是建议回收。垃圾回收精确性包括两个方面：1.精确的标记着活的对象，2精确的定位对象间的引用关系。

整数类型：byte(1),short(2),int(4),long(8)字符类型char(2),浮点类型float（4)，double(8),boolean

jdk7中数字可以使用下划线区别位数

long long1=2_1252L;
System.out.println(long1);
		

将非字符串字符串化

 float f=1.05f;
String s=f+"";//将非字符串字符串化
System.out.println(s);

int val=233;      //32位00000000 00000000 00000000 11101001
byte b=(byte)val; //强转                           11101001                                                             
System.out.println(b);// -23                       反   11101000//原码10010111

强转原理

System.out.println("hello"+'a'+1);//helloa1 一开始进行的是字符串运算
System.out.println('a'+1+"hello");//98hello 先从char上升到int做加法运算再和hello连用

数组的静态初始化：初始化决定数组的值，由系统分配长度

数组的动态初始化：定义好数组长度，系统分配默认值。

可用class类表示c++中的结构体

class stu{
	int age;
	int grade;
	stu next;//指针
	public void p(){
		System.out.println(age+grade);
	}
}

在main函数里面调用非静态方法

public class git{
	
   int age;
   public void p(){
	   this.age=10;
	   System.out.println(age);
   }
   public static void main(String[] args) {
	   new git().p();//new 自身调用方法
		
	}
  
}

方法里面传递多个参数

public class git{
	public static void test(int a,String ...books){
		for(String s:books){
			System.out.println(s);
		}
	}
	public static void main(String[] args) {
		test(20,"java","se","me");
	}
  
}

构造器重载代码升级

public class git{
	private int age;
	private String name;
	private String hobby;
	public  git(int age,String name){
		this.age=age;
		this.name=name;
	}
    public  git(int age,String name,String hobby){
    	this(age,name);//这里可以照抄，但是不建议。万一前面的改了后面也要改，麻烦。如果是继承关系。git(int age,String name)属于父类的话，用super（age，name）
    	this.hobby=hobby;
    }
}

多态：Java引用变量有两个类型。编译时类型，与运行时类型、编译时类型声明的变量时的使用类型决定的，运行时类型由实际赋给该变量的对象决定。如果编译时与运行时类型不一致，就可能出现多态。

Java类中的初始化顺序，代码块先执行（成员变量也这个顺序），按顺序，再构造函数的初始化。代码块用来抽取构造函数公共的地方。在Javac编译后，代码块会怎么分配到构造函数的下面。

自动包装类型，采用基本数据类型对应的包装类，可采用静态方法valveof与parsexxx进行转换。

final关键字的好处

class test{
	public static void main(String[] args) {
	final int a=5;//final定义的宏变量下面直接翻译为5了a实则不存在的
	System.out.println(a);//System.out.println(5)编译期间就是5了
}
}

下面第一行打印s1==s2因为字符串存在常量区，在编译期间就知道指向相同的地方，对于s5编译器不会做宏替换，无法在编译时确定值，无法让S5指向常量区的字符串，对s3与s4加final即可打印true。

String s1="疯狂java";
	String s2="疯狂"+"java";
	System.out.println(s1==s2);//true
	String s3="疯狂";
	String s4="java";
	String s5=s3+s4;
	System.out.println(s1==s5);//false

 Integer i=new Integer(6);//返回的是全新的对象
 Integer i1=Integer.valueOf(6);//缓存创造的对象，需大量使用时可以用这个，不过只缓存-128-127之间的数字
  System.out.println(i==i1);//false 

枚举的基本使用，枚举不是类，

interface act{
	public abstract void action();
}
enum  gender{
	male("男"),femal("女");//自己造实例
	private final  String name;
	private gender(String name){//必须私有构造
		this.name=name;
	}
	public String getName(){
		return this.name;
	}
	public void action(){
		System.out.println("我是接口");
	}
}
class  test{
	public static void main(String[] args) {
	gender femal = gender.femal;
	String name = femal.getName();
	femal.action();
	System.out.println(name);
	}
	}

java9之前字符串采用char[]数组保存，一个字符两个字节。9之后采用byte[]数组再加encodingflag保存字段，每个字符占据一个字节。

bigDecimal一般解决精度丢失的问题，一般在new对象时传入字符串可解决精度丢失问题。

iterator迭代器在获取迭代器对象时，不能对集合中的对象进行修改，会引起报错。for循环亦是如此。

object类中的hashcode有native修饰，这其中的代码由底层其他语言编写。

泛型：

        A:把运行时期的问题提前到了编译期间（比如说在list中添加string和integer在遍历时使用强转会有问题）
        B:避免了强制类型转换
        C:优化了程序设计，解决了黄色警告线问题，让程序更安全

list<string>与list<integer>本质上是一样的，用l.getClass是相等的，虽然是泛型，但并没有解析成新的class文件。

？泛型对象时只读的，泛型与通配符典型的应用

public static <T> void Collections.copy(List<T> dest, List<? extends T> src) { ... }

从src拷贝到dest，那么dest最好是src的类型或者其父类，因为这样才能类型兼容，并且src只是读取，没必要做修改，因此使用?还可以强制避免你对src做不必要的修改，增加的安全性。

异常try ()里面可以初始化需要close的对象，在里面默认了自动关闭相当于隐式finally。

运行期异常可以通过代码解决，例如1/0可以加判断，编译期间异常必须try或者throw了.

异常的初衷是实现不可预知的错误与业务的分离，而不是用异常与普通ifelse语句混用，对于可以预知的错误用逻辑判断执行。

在序列化中，进行实现序列化接口即可实现序列化。若需要序列化的对象有其他对象的引用，则在第一次使用时序列化，第二次以后则记住编号，如不想对象的某个变量在反序列化时读取出来，则加上static或者transizent关键字。即将变量隔离在序列化机制之外。

采用对象流objectinputstream进行读取。

externalizable也可实现序列化，但是需要实现两个方法，且需要指定存储哪些信息。

serialversionid保证序列化后的对象与反序列化的对象相同。

NIO采用内存映射文件的方式，将文件或文件的一段区域读取到内存中，可以像访问内存一样访问文件了，速度很快。

scanner知识点

            Scanner sc=new Scanner(System.in);
		
			String next1 = sc.next();//遇到制表符就不会读取了如输入hello world
			System.out.println(next1);//hello
			String next2 = sc.nextLine();//缓冲区还有数据源，不能输入，自动拿数据
			System.out.println(next2);// world