欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Java知识点归纳总结

程序员文章站 2023-12-17 08:30:40
1. 基本数据类型 整形: byte      1 个字节 short   &nbs...

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

上一篇:

下一篇: