java重点知识总结

2020-06-26总结

  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

  {

  //无须创建内部类实例

  }

【java重点知识总结】相关文章:

1.java集合知识点总结

2.java框架知识点总结

3.春望重点知识点总结

4.医学基础知识重点总结

5.儿科重点知识点总结

6.初中政治重点知识总结精选

7.java面试知识点总结

8.java基础知识点总结

上一篇:反应堆热工课程设计研究论文下一篇:java io流学习总结