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  或者 对一个负数开方  得到一个非数

整数除以0 会抛出异常

5. 在java中布尔类型只能是true和false

6. 在java中没有多维数组

看似像C语言中的多维数组不是真正的数组，比如 a[3][4] , a[0] a[1] a[2]  是真实存在的，装的是地址，和c语言中动态分配为的数组一样

int  [][]  b  = new  int[3][4]

每个数组都有一个属性length

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
{
	//无须创建内部类实例
}

22. java子类方法的重载

23. 类中 equals方法的标准写法

要求：x.equal(null)  返回 false

public boolean equals(Object obj)
{
	// 如果两个对象为同一个对象
	if (this == obj)
		return true;
	//只有当obj是Person对象
	if (obj != null && obj.getClass() == Person.class)
	{
		Person personObj = (Person)obj;
		//并且当前对象的idStr与obj对象的idStr相等才可判断两个对象相等
		if (this.idStr.equals(personObj.idStr))
		{
			return true;
		}
	}
	return false;
}