java重点知识总结

　　java是一门软件语言，学习软件技术的同学们都要学会JAVA编程技术！以下是java重点知识总结，一起来看看吧！

　　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

　　{

　　//无须创建内部类实例

　　}