Java知识点归纳总结
1. 基本数据类型
整形：
byte 1 个字节
short 2 个字节
int 4个字节
long 8个字节
字符：
char 2个字节
浮点数：
float 4个字节
double 8个字节
布尔：
boolean 1个字节
2.java 7 新增二进制整数
以0b或者0b开头
3.java中字符时16位的unicode编码方式，格式是'\uxxxx'，其中xxxx代表一个十六进制整数
4.java中规定了正无穷大、负无穷大和零
正无穷大= 一个正数除以0
负无穷大= 一个负数除以零
0.0 除以0.0 或者 对一个负数开方 得到一个非数
5. 在java中布尔类型只能是true和false
6. 在java中没有多维数组
看似像c语言中的多维数组不是真正的数组，比如 a[3][4] , a[0] a[1] a[2] 是真实存在的，装的是地址，和c语言中动态分配为的数组一样
int [][] b = new int[3][4]
7. java中带包的编译方法
javac -d . hello.java 会在当前目录下生成目录树
运行 java 包名字.类名字
8. java多态中的对象的filed 不具有多态性，如 父类 对象 = new 子类（）， 对象.field 是调用的父类的，即使子类中覆盖了该字段。
9. instanceof 运算符
格式： 引用变量名 instanceof 类名（或者接口） 他用于判断前面的对象是否是后面对象的类，子类、实现类的实例，是返回true，否者返回false
10. java 中基本数据类型和对应封装类之间的转化
int a = 1;
integer a = new integer(a);
a = a.intvalue();
其他的类型也是这样的。
11.单例（singleton）类 例子
class singleton
{
private static singleton instance;
private singleton(){}
public static singleton getinstance()
{
if(instance == null)
{
instance = new singleton();
}
return instance;
}
public static void main(string[] args)
{
singleton s1 = singleton.getinstance();
singleton s2 = singleton.getinstance();
system.out.println(s1 == s2);
}
}
12.final修饰的成员变量初始化问题
类field： 必须在静态初始块中或声明该field时指定初始值
实例field：必须在非静态初始块中或声明该field时指定初始值或构造器中声明
13.final 变量必须显式初始化，系统不会对final变量进行隐式初始化
14.java会使用常量池来管理曾经用过的字符串直接常量，例如：string a = "java"; ，系统把常量字符串“java”存在常量池，当再次执行 string b = "java"; a == b 是true
15.final 方法不可以重写，final类不能被继承
如果用private 方法 和 final private 是一样的
若果是用final修饰的方法在子类中出现，那是子类新定义的，与父类没有关系
16.不可变类：创建后该类的field是不可改变的。java提供了8个基本变量的包装类和string都是不可改变类。
17.缓存实例的不可改变类
class cacheimmutale
{
private static int max_size = 10;
private static cacheimmutale[] cache = new cacheimmutale[max_size];
private static int pos = 0;
private final string name;
private cacheimmutale(string name)
{
this. name = name;
}
public string getname()
{
return name;
}
public static cacheimmutale valueof(string name)
{
for(int i = 0; i < max_size; ++i)
{
if(cache[i] != null && cache[i].getname().equals(name))
return cache[i];
}
if(pos == max_size)
{
cache[0] = new cacheimmutale(name);
pos = 1;
}
else
{
cache[pos++] = new cacheimmutale(name);
}
return cache[pos -1];
}
public boolean equals(object obj)
{
if(this == obj)
return true;
if(obj != null && obj.getclass() == cacheimmutale.class)
{
cacheimmutale ci = (cacheimmutale)obj;
return name.equals(ci.getname());
}
return false;
}
public int hashcode()
{
return name.hashcode();
}
}
public class cacheimmutetest
{
public static void main(string[] args)
{
cacheimmutale c1 = cacheimmutale.valueof("hello");
cacheimmutale c2 = cacheimmutale.valueof("hello");
system.out.println(c1 == c2);
}
}
用缓存实例要看某个对象的使用频率，若重复使用那就利大于弊，若不经常使用那弊就大于利
还有java提供的java.lang.integer 创建数值在-128-127之间的数采用缓存机制的
integer in2 = integer.valueof(6);
integer in3= integer.valueof(6);
in2 == in3 is true;
18. static 和 abstract 不能同时修饰一个方法，没有类抽象方法
19.一个类可以又一个父类，实现多个接口，接口中filed是public 、static、final的，方法是public abstract的
20.非静态内部类的方法访问某个变量，搜索顺序为：先内部类中方法内-> 内部类 -> 外部类中如果都找不到则出现编译错误
import java.util.*;
public class discernvariable
{
private string prop = "外部类的实例变量";
private class inclass
{
private string prop = "内部类的实例变量";
public void info()
{
string prop = "局部变量";
system.out.println("外部类的field值：" + discernvariable.this.prop);
system.out.println("内部类的field值：" + this.prop);
system.out.println("局部变量的值：" + prop);
}
}
public void test()
{
inclass in = new inclass();
in.info();
}
public static void main(string[] args)
{
new discernvariable().test();
}
}
21.非静态内部类不能有静态方法、静态field、静态初始化块
22.在外部类之外访问内部类
访问非静态内部类：outclass.inclass varname = new outclass().new inclass();
访问静态内部类： outclass.inclass varname = new outclass.inclass();
import java.util.*;
class out
{
class in
{
public in()
{
system.out.println("非静态内部类构造器");
}
}
}
public class creatinnerinstance
{
public static void main(string[] args)
{
out.in in = new out().new in();
/*
以上的代码可分开写为：
out.in in;
out out = new out();
in = out.new in();
*/
}
}
class subclass extends out.in
{
//显示定义subclass的构造器
public subclass(out out)
{
//通过转入的out对象显示调用in的构造器
out.super();
}
}
import java.util.*;
class staticout
{
static class staticin
{
public staticin()
{
system.out.println("静态内部类构造器");
}
}
}
public class creatstaticinnerinstance
{
public static void main(string[] args)
{
staticout.staticin in = new staticout.staticin();
/*
以上的代码可分开写为：
staticout.staticin in;
in = new staticout.staticin();
*/
}
}
class subclass extends staticout.staticin
{
//无须创建内部类实例
}