--动力节点之java的知识点归纳总结

Integer in2 = Integer.valueOf(6);
Integer in3= Integer.valueOf(6);
in2 == in3 is true;
18. static和abstract不能同时修饰一个方法，没有类抽象方法
19.一个类可以又一个父类，实现多个接口，接口中Filed是public、static、final的，方法是public abstract的
{
//通过转入的Out对象显示调用In的构造器
out.super();
}
}
复制代码代码如下:
import java.util.*;
class StaticOut
{
static class StaticIn
{
public StaticIn()
{
System.out.println("静态内部类构造器");
System.out.println("局部变量的值：" + prop);
}
}
public void test()
{
InClass in = new InClass();
();
}
public static void main(String[] args)
{
new DiscernVariable().test();
{
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))
CacheImmutale c2 = CacheImmutale.valueOf("Hello");
System.out.println(c1 == c2);
}
}
用缓存实例要看某个对象的使用频率，若重复使用那就利大于弊，若不经常使用那弊就大于利
还有java提供的ng.Integer创建数值在-128-127之间的数采用缓存机制的
private static CacheImmutale[] cache = new CacheImmutale[MAX_SIZE];
private static int pos = 0;
private final String name;
private CacheImmutale(String 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)
}
}
}
public class CreatStaticInnerInstance
{
public static void main(String[] args)
{
StaticOut.StaticIn in = new StaticOut.StaticIn();
/*
以上的代码可分开写为：
StaticOut.StaticIn in;
}
}
21.非静态内部类不能有静态方法、静态Field、静态初始化块
22.在外部类之外访问内部类
访问非静态内部类：outclass.Inclass varname = new outclass().new InClass();
访问静态内部类：outclass.Inclass varname = new outclass.Inclass();
14.java会使用常量池来管理曾经用过的字符串直接常量，例如：String a = "java";，系统把常量字符串“java”存在常量池，当再次执行String b = "java"; a == b是true
15.final方法不可以重写，final类不能被继承
如果用private方法和final private是一样的
9. instanceof运算符
格式：引用变量名instanceof类名（或者接口）他用于判断前面的对象是否是后面对象的类，子类、实现类的实例，是返回true，否者返回false
10. Java中基本数据类型和对应封装类之间的转化
int a = 1;
Integer A = new Integer(a);
}
return false;
}
public int hashCode()
{
return name.hashCode();
}
}
public class CacheImmuteTest
{
public static void main(String[] args)
{
CacheImmutale c1 = CacheImmutale.valueOf("Hello");
int [][] b = new int[3][4]
7. Java中带包的编译方法
javac -d . Hello.java会在当前目录下生成目录树
运行java包名字.类名字
8. Java多态中的对象的filed不具有多态性，如父类对象= new子类（），对象.field是调用的父类的，即使子类中覆盖了该字段。
{
if(this == obj)
return true;
if(obj != null && obj.getClass() == CacheImmutale.class)
{
CacheImmutale ci = (CacheImmutale)obj;
return name.equals(ci.getName());
in = new StaticOut.StaticIn();
*/
}
}
class SubClass extends StaticOut.StaticIn
{
//无须创建内部类实例
}
复制代码代码如下:
import java.util.*;
class Out
{
class In
{
public In()
{
System.out.println("非静态内部类构造器");
}
}
}
public class CreatInnerInstance
{
public static void main(String[] args)
若果是用fi系
16.不可变类：创建后该类的Field是不可改变的。java提供了8个基本变量的包装类和string都是不可改变类。
17.缓存实例的不可改变类
复制代码代码如下:
class CacheImmutale
{
private static int MAX_SIZE = 10;
System.out.println(s1 == s2);
}
}
12.final修饰的成员变量初始化问题
类Field：必须在静态初始块中或声明该FIeld时指定初始值
实例Field：必须在非静态初始块中或声明该FIeld时指定初始值或构造器中声明
13.Final变量必须显式初始化，系统不会对final变量进行隐式初始化
20.非静态内部类的方法访问某个变量，搜索顺序为：先内部类中方法内->内部类->外部类中如果都找不到则出现编译错误
复制代码代码如下:
import java.util.*;
public class DiscernVariable
{
private String prop = "外部类的实例变量";
private class InClass
{
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)
{
private String prop = "内部类的实例变量";
public void info()
{
String prop = "局部变量";
System.out.println("外部类的field值：" + DiscernVariable.this.prop);
System.out.println("内部类的field值：" + this.prop);
a = A.intValue();
其他的类型也是这样的。
11.单例（singleton）类例子
复制代码代码如下:
class Singleton
{