当前位置：首页 > 资讯 > 技术文档

Java知识点归纳总结

时间：2022-07-01 11:01 编辑：来源：阅读：
扫一扫，手机访问

摘要：Java知识点归纳总结

[b]1. 基本数据类型[/b] [b]整形： [/b] byte 1 个字节 short 2 个字节 int 4个字节 long 8个字节字符： char 2个字节浮点数： float 4个字节 double 8个字节布尔： boolean 1个字节 [b]2.java 7 新增二进制整数[/b] 以0b或者0B开头 [b]3.java中字符时16位的Unicode编码方式，格式是'\uXXXX'，其中xxxx代表一个十六进制整数[/b] [b]4.java中规定了正无穷大、负无穷大和零[/b] 正无穷大= 一个正数除以0 负无穷大= 一个负数除以零 0.0 除以0.0 或者对一个负数开方得到一个非数 [b]5. 在java中布尔类型只能是true和false[/b] [b]6. 在java中没有多维数组[/b] 看似像C语言中的多维数组不是真正的数组，比如 a[3][4] , a[0] a[1] a[2] 是真实存在的，装的是地址，和c语言中动态分配为的数组一样 int [][] b = new int[3][4] [b]7. Java中带包的编译方法[/b] javac -d . Hello.java 会在当前目录下生成目录树运行 java 包名字.类名字 [b]8. Java多态中的对象的filed 不具有多态性，如父类对象 = new 子类（），对象.field 是调用的父类的，即使子类中覆盖了该字段。[/b] [b]9. instanceof 运算符[/b] 格式：引用变量名 instanceof 类名（或者接口）他用于判断前面的对象是否是后面对象的类，子类、实现类的实例，是返回true，否者返回false [b]10. Java 中基本数据类型和对应封装类之间的转化[/b] int a = 1; Integer A = new Integer(a); a = A.intValue(); 其他的类型也是这样的。 [b]11.单例（singleton）类例子 [/b]

[u]复制代码[/u] 代码如下:

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);
        }
}

[b]12.final修饰的成员变量初始化问题[/b] 类Field：必须在静态初始块中或声明该FIeld时指定初始值实例Field：必须在非静态初始块中或声明该FIeld时指定初始值或构造器中声明 [b]13.Final 变量必须显式初始化，系统不会对final变量进行隐式初始化[/b] [b]14.java会使用常量池来管理曾经用过的字符串直接常量，例如：String a = "java"; ，系统把常量字符串“java”存在常量池，当再次执行 String b = "java"; a == b 是true[/b] [b]15.final 方法不可以重写，final类不能被继承[/b] 如果用private 方法和 final private 是一样的若果是用final修饰的方法在子类中出现，那是子类新定义的，与父类没有关系 [b]16.不可变类：创建后该类的Field是不可改变的。java提供了8个基本变量的包装类和string都是不可改变类。[/b] [b]17.缓存实例的不可改变类 [/b]

[u]复制代码[/u] 代码如下:

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; [b]18. static 和 abstract 不能同时修饰一个方法，没有类抽象方法[/b] [b]19.一个类可以又一个父类，实现多个接口，接口中Filed是public 、static、final的，方法是public abstract的[/b] [b]20.非静态内部类的方法访问某个变量，搜索顺序为：先内部类中方法内-> 内部类 -> 外部类中如果都找不到则出现编译错误 [/b]

[u]复制代码[/u] 代码如下:

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();
 }
}

[b]21.非静态内部类不能有静态方法、静态Field、静态初始化块 22.在外部类之外访问内部类 [/b] 访问非静态内部类：outclass.Inclass varname = new outclass().new InClass(); 访问静态内部类： outclass.Inclass varname = new outclass.Inclass();

[u]复制代码[/u] 代码如下:

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();
 }
}

[u]复制代码[/u] 代码如下:

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

全部评论(0)

上一篇：java 汉诺塔详解及实现代码
下一篇：java生成图片验证码实例代码

资讯排行榜
更多>>