【Java入门知识】

Java基础知识

1、关键字

2、标识符

3、基本类型和引用类型

4、public、default、protected、private

5、构造方法：

6、this 和 super

7、== 和 equals

8、字符容器（String、StringBuffer、StringBuilder）

9、File(Java 文件操作)

10、流  

11、字符问题

12、接口（implements）

13、泛型

14、枚举

15、hashcode和equals  (MD5的计算是目前最广泛的哈希算法)

16、网络通信（Socket）

17、system.out.print():  类名.成员变量.静态方法

18、语法基础

 // 陌生单词：compile编译、deprecation过时、PermGen永久代(方法区)、Heap堆内存

 

1、关键字

修饰符：  abstract、class、final、private、protected、public、static、7

数据类型：boolean、byte、char、double、float、int、long、short、void、9

语句组成：break、case、catch、continue、default、do、else、extends、finally、 for、if、implements、import、instanceof、interface、new、package、 return、super、switch、sychronized、this、throw、throws、try、while26

特殊含义关键字：assert、const、goto、enum、native、strictfp、transient、volatile、7

assert: 断言，用于调试，多被junit代替，IDE默认不开启。

const：预留关键字。

goto：预留关键字。

enum: 枚举。

native: 本地方法。

strictfp: 精确浮点，可用于类、接口、方法。

transient: 免除变量序列化。===》Serilizable 将一个对象按照同一个格式转化成字节流。

volatile: 被设计用来修饰被不同线程访问和修改的变量。==可见性

非java关键字：true、false、sizeof、null、serilizable、

 

 

2、标识符

  标识符是用来标识类名、变量名、方法名、类型名、数组名及文件名的有效字符序列。

  1、标识符由字母、数字、下划线、美元符号组成，长度不受限制。

  2、第一个字符不能为数字。

  3、标识符不能是关键字。

  4、标识符不能是true、false、null(字面常量)

 

 

3、基本类型和引用类型

Java中基本类型有四类八种，也称为原生类、内置类。其余的都属于引用类型

  整数：(byte1、short2、int4、long8)       引用类型：(Byte、Short、Integer、Long)

  浮点：(float4、double8)                        引用类型：(Float、Double)

  字符型：(char2)                                    引用类型：(Character)

  逻辑型：(bolean1)                                引用类型：(Boolean)

 

nume(枚举)是特殊数据类型，即是一种类，又比类多一些约束。

String是一个类。

 

  一个字符常量表示一个字符或一个转义字符，被一列ASCII单引号包裹。

 数组无论是定义实例变量还是局部变量，若没有初始化，都会被自动初始化。

   char[] ch = new char[3];  //默认空格

   int []  arr = new int[2];  //默认0

   String[] string = new String[2];  //默认null

 

Byte类型引用包装类默认为null,byte的默认值为0，byte[-128,127]

char类型存储unicode码，占两个字节16位，默认值为’’,默认使用GBK编码，可存中文汉字。UTF-8一个汉字占3个字节，GBK占两个字节。

java中的小数类型默认值为double.

 

------------------------------有待整理----------------------------

包装类型：Integer a=1; a=2; 在方法内===>等于重新new一个a对象，

 在方法外===>等于改变a的指向地址，

包装类对象做基本操作(拆比较、计算)会拆箱，不再是引用传递。

引用类型一般有 数组(数组是一种对象，有行为，大小一旦确定，不能改变)、类、接口。

a = Integer.parseInt(“1024”);==>parseInt把String对象类型转换为 int。

b= Integer.ValueOf(“1024”).intValue(); ===>ValueOf把String转换为Integer类型，(JDK支持装箱拆箱)，intValue(); 把Integer类型转化为int类型。

 

Integer i01 = 59;会调用Integer的valueOf方法，判断是否在[-128,127]之间，返回引用或新建对象。

int i02 = 59;基本类型，存储在栈中。

Integer i03 = Integer.valueOf(59);直接返回引用(IntegerCache中的对象引用)

Integer i04 = new Integer(59); 直接创建一个新的对象

i01 == i02; ===>Integer会拆箱成int,做值之间比较  true

i02 == i04; ====>Integer会拆箱成int,做值之间比较 true

 

 

包装类相关：

  两种不同类型的引用不能进行”==”比较,例如：Integer和Double

包装类也重写equals,没有常量池，Integer  s = new Integer(q)；Integer t = new Integer(q)；强制在堆内存创建 q 对象实例。

s.equals(q);在进行equals比较之前，会对q调用Integer.valueOf;进行自动装箱，由于IntegerCache中已经存在q,所以，直接创建了一个新的Integer实例，但值也是q,比较值，满足条件，返回真。

 

 ------------------------------有待整理----------------------------

 

 

4、public、default、protected、private

   访问权限 主要区别在于 异包子类。

 

5、构造方法：

  构造方法可以被public、private、Protected修饰，不能被继承。

 

 private 修饰构造方法：

当构造方法为private级别时，意味着只能在当前类访问它，不能被继承，不能被其他程序用new创建实例对象。

 

protected 修饰构造方法：

如果构造函数是protected,那么该类可以继承,可以在被包内其他类中产生实例,但是无法在包外或者子类以外的地方产生实例.

 

6、this 和 super

  this: 表示某个对象，this可以出现在实例方法和构造方法中，但不可出现在类方法中。

  this出现在构造方法中，代表当前对象，一般省略。

  this出现在实例方法中，代表正在调用当前方法的对象，成员变量和局部变量重名时出现，多出现在set方法中，对象的成员变量。

 

 super：子类一旦隐藏了继承的成员变量（子类重写了父类方法、父类的构造方法、static方法），那么子类创建的对象就不再拥有该变量，该变量就归super关键字所拥有。

在子类的构造函数中默认有super();

父类没有无参构造时，需在子类的构造方法中显式调用super(“xxx”);

  只有在重写了父类的方法之后，再调用父类的方法需要使用super调用。  

父类静态方法不能被子类重写，只是被隐藏，也需要使用super调用。

 

7、==  和 equals

   == 比较类型和值(也可以说是比较地址)。在基本类型上，比较值，在对象引用类型上，比较地址。

   equals 底层也采用 == 做比较，但String中重写了Object中的此方法，用于比较字符串的内容。

 

  Object中equals的源码，没有重写equals时，底层直接用“==”做判断。而String中重写了方法。

  public boolean equals(Object obj){
     return (this==obj);
}

String 重写后的equals方法：

 public boolean equals(Object anObject) {
        if (this == anObject) {  // 判断是不是本身
            return true;
        }
        if (anObject instanceof String) {   // 判断 是不是属于String实例
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {  // 判断是不是长度相等 
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {    // 判断是不是某个值为 0
                    if (v1[i] != v2[i])   // 判断对应位置的值 是不是一致
                        return false;
                    i++;
                }
                return true;   // 内容完全符合，就返回 true
            }
        }
        return false;
    }

以上的equals方法中，存在一个问题，使用 a.equals（b）时，很有可能会抛出NullPointExceprion，所以可以考虑使用下面的方法：使用org.apache.commons.lang包下的StringUtils.equals(String str1, String str2)方法

源码：

public static boolean equals(String str1, String str2){
        return str1 != null ? str1.equals(str2) : str2 == null;
    }
　　//忽略大小写进行比较
    public static boolean equalsIgnoreCase(String str1, String str2) {
        return str1 != null ? str1.equalsIgnoreCase(str2) : str2 == null;
    }

StringUtils.equals这个方法了吧。他已经帮你绕过了那个坑。

 

8、字符容器（String、StringBuffer、StringBuilder）

 String传递是引用传递，StringBuffer、StringBuffer是引用传递===>可改变内容，不可改变引用地址。

 String s = new String(“xyz”);  分常量池和堆。

  xyz可能存在于两个地方，编译期遇到”xyz”,检测到常量池没有xyz存在，就在常量池中创建一个xyz常量。

     new String(“xyz”)会在执行时，在堆中创建一个实例。==>指向常量池？

 

三者的主要区别在于 运行速度 和 线程安全上。 

       首先，运行速度上，StringBuilder  > StringBuffer > String 。

　    String为字符串常量，而StringBuilder和StringBuffer均为字符串变量，即String对象一旦创建之后该对象是不可更改的，但后两者的对象是变量，是可以更改的。实例如下：

String a = "abc";
System.out.println(a);
a = a + "def";
System.out.println(a); 

代码先输出 abc，然后输出 abcdef。原理上看是修改了 a 字符串 的内容，而实际上在执行到第三行的之后，JVM对 a 字符串进行了 gc 回收操作，然后创建了一个新的字符串，用来存储“abcdef”的值。Java中对于String的处理是一旦创建是不能被修改的，所以Java中对于String的处理 是一个不断创建和不断回收的过程，所以执行非常慢。

     而StringBuilder和StringBuffer的对象是变量，对变量进行操作就是直接对该对象进行更改，而不进行创建和回收的操作，所以速度要比String快很多。在使用了StringBuild之后，实例如下：

String  a = "abc"+"def";
StringBuilder sb = new StringBuilder().append("abc").append("def");
System.out.println(a);
System.out.println(sb。toString());

可以发现，StringBuilder的执行速度并没有String的执行速度快，这是因为String a = "abc"+"def" 的作用等同于

String  a = “abcdef” 。

 如果写成以下形式，执行速度就不一样了：

String a = "abc";
String b = "def";
String a = a + b; 
System.out.println(a);

   如此一来，Jvm就会不断的创建和回收 String对象，从而实现其功能。

 

    然后，是线程安全的问题。

        三者中，只有StringBuffer是线程安全的。主要应用于缓存中。因为多数方法都是使用了synchronized修饰的，所以进行操作需要获取到同步方法的权限。StringBuilder的方法没有被sychronized关键字修饰，所以是不安全的。            

 

综上所述：

     在需要线程安全的情况下，应该使用StringBuffer。

    不考虑线程安全的情况下，应该使用StringBuilder，执行速度最快。

    在少量字符串操作的情况下，使用String最佳。

 

 

 

 

 

9、File(Java 文件操作)

1) File类是对文件整体或者文件属性操作的类，例如：创建文件，删除文件等，文件内容用IO流操作。

2) 能用文本文档打开的都是文本文件(文本打开乱码都不是文本文件)，用特殊应用打开的都是二进制文件。

3) 输出过程到达文件或流的末尾，会抛出EOFException，正常情况异常 会被处理返回特殊值(read()会返回-1)。

 

10、流  字节流（字节数组）经过 解码 可转换为 字符流（字符串没有意义）= 字符流+编码集 = 字节流

字节流继承于InputStream、OutputStream

字符流继承 InputStreamReader/OutputStreamWriter    

 

1)InputStreamReader的构造函数：

 InputStreamReader(InputStream  in): 创建一个使用默认字符集的InputStreamReader.

InputStreamReader(InputStream in,Charset cs):创建使用给定字符集的InputStreamReader

InputStreamReader(InputStream in,CharsetDecoder dec):创建使用给定解码字符集的InputSt..

InputStreamReader(InputStream in,String charsetName):创建使用给定字符集的InputStream..

BufferedReader的构造函数：

BufferedReader(Reader in):创建使用默认大小输入缓冲区的缓冲字符输入流

BufferedReader(Reader in,int size):创建使用指定大小输入缓冲区的缓冲字符输入流

 

Writer的构造函数：

Protected ... Writer( ):创建一个字符流writer，其作用是同步到writer自身，

Protected...Writer(Object  lock):创建一个字符流writer，作用是同步到给定的对象

 

管道流：管道实际上是一个大小固定的缓冲区，管程对于管道两端的进程而言，就是一个文件，但它不是普通文件，它单独构成一种文件系统，并且只存在内存中，类似于半双工通信。管道的内存大小通常是内存上的一页，它的大小并不受磁盘容量大小的限制。当管道空时，进程读操作会堵塞，管道满时，写操作会堵塞。

PipedInputStream的构造函数：

PipedInputStream():创建一个尚未连接的PipedInputStream.

PipedInputStream(int pipeSize):创建尚未连接的PipedInputStream，并指定管道缓冲区的大小

PipedInputStream(PipedOutStream src):创建PipedInputStream，连接到管道输出流src

PipedInputStream(PipedOutputStream sc,int pipeSize):创建PipedInputSt...，指定大小,连接src。

 

11、字符问题

  java语言使用Unicode字符集，而ASCII是国际上使用最广泛的字符编码，BCD是一种数字压缩存储编码Unicode(又称统一码、万国码、单一码)是计算机学领域上的一项业界标准，包括字符集、编码方案等，为每种语言的每个字符设定了统一并且唯一的二进制编码，以满足跨语言，跨平台的文本转换。一个unicode(中英文一样)占两个字节(16bit)。

UTF-8、UTF-16、UTF-32都是将Unicode装换到程序数据的编码方案。

JVM使用UTF-16保存字符。

  编码(Unicode)就是一个编号(数字)到字符的一种映射关系，一对一的映射表。

  编码格式(UTF-8)就是序列化或存储编码中的那个编码的一种”格式”。

 

中文汉字在java(Unicode)中占两个字节，在utf-8中占三个字节，在gbk中占两个字节。

 

标准ASCII 只使用7个bit,扩展的ASCII 使用8个bit,ASCII 中包括一些不可打印字符，0-31分配给不可打印字符，

ANSI通常使用0x00--0x7f范围的一个字节来表示1个英文字符，即扩展的ASCII编码。代表本地编码格式。

  简体中文windows中，ANSI代表GBK,GB2312 是国标。

  繁体中文  ANSI代表 Big5。

  日文中   ANSI 代表shift_JIS。

 

12、接口（interface）

1. 接口中声明的成员变量默认为public static final成员。（不管是基础还是引用类型）且必须初始化。

2. 接口中的方法默认是public abstract且没有方法体，但可以有参数,不设访问权限。

3. 实现接口的类如果是普通类，必须重写接口的所有方法，且不能降低访问修饰符，显示标注为public。如果是抽象类，不用重写所有的抽象方法。

 4. 接口没有构造函数，所以不能实例化。

4. 在jdk1.8之后，接口添加了默认的方法，在返回值加上default关键字，然后还有方法体；在接口被实现时，可以直接继承或者重新声明。

5. 还添加了静态方法。

 

13、泛型

   泛型防止代码编写出错，在编译期，泛型会被擦除，并不会影响运行速度。

 

14、枚举

     枚举是JDK1.5新增的特性，它是一种新的类型，表示特定的数据片段，类型安全，是特殊类，拥有成员变量和方法。 

  所有的枚举值都是类静态常量，在初始化时会对所有的枚举值对象进行一次初始化。

 

15、hashcode  和 equals  (MD5的计算是目前最广泛的哈希算法)

哈希又称散列，通过散列算法将任意长度的输入变成固定长度的输出，又称散列值，是一种压缩映射，散列值可能相同。

    1) 如果两个对象相等，那么他们一定有相同的哈希值。  

    2) 如果两个对象哈希值相等，它们不一定相等。需要用equals判断。

 

hash值： 具有等幂性(对象不变,做多少次计算hash值都不变)、

对等性(equals计算两个对象相等，而hash值一定对等)、

互异性(若两个对象equals为false，而hash值最好也不同)

hash值的计算一般采用 多个成员变量的hash值相加，或 加权值

对象的hash值做key。

 

16、网络通信（Socket）

服务器端：ServerSocket server = new ServerSocket(端口号)；

服务器端的常用方法：

    ServerSocket(int port)、accept()、close()、getInetAddress()、getLocalPort()

客户端： Socket soc = new Socket(ip地址，端口号);  

客户端的常用方法：

    Socket(InetAddress address, int  port)、 Socket(String  host, int port)、close()  

 

17、system.out.print():  类名.成员变量.静态方法

  system是java.lang的一个类，out是system内的一个成员变量，这个变量是java.io.PrintStream类的对象。println()是java.io.PrintStream类的方法，所以可以调用类.成员变量.println()方法。

18.  Json语法可以用来表示以下三个类型的值：

JSON对象中要求属性必须加双引号“”。

 

19. 接口相关

 

1. 接口中声明的成员变量默认为public static final成员。（不管是基础还是引用类型）且必须初始化。

2. 接口中的方法默认是public且没有方法体，但可以有参数。

3. 实现接口的类如果是普通类，必须重写接口的所有方法，且不能降低运用域，显示标注为public。如果是抽象类，不用重写所有的抽象方法。

 

4. 在jdk1.8之后，接口添加了默认的方法，在返回值加上default关键字，然后还有方法体；在接口被实现时，可以直接继承或者重新声明。

 

5. 还添加了静态方法。

 

1. 简单值：使用与JavaScript相同的语法，可以在JSON中表示字符串 数值 布尔值或者null。

2. 对象：对象作为一种复杂数据类型，表示的是一组有序的键值对。而每组键值对中的值可以是简单值，也可以是复杂数据类型的值。

3. 数组也是一种复杂的数据类型，表示一组有序的值的列表。可以通过索引来访问其中的值。数组的值可以是任意类型的简单值、对象或者数组。

 

 

 

18、语法基础

1、if(x=y)==>会出错，发生类型强转异常。(mismatch) 。

2、int x=1;float y=2;  x/y=1.0/2.0=0.5==>发生自动转型，byte-short-char-int-long-float-double  1 2 2 4 8 4 8

3、public class A extends B implements C{}  ===>先继承再实现

4、package在程序文件的第一句，且没有注释。

5、float f = 1.0f;  f必须有。否则默认为 double 

6、int a[] = null;  a[0] = 1;  抛出NullPointException。

7、<< 左移，乘以2的n次方， << 无符号左移，末尾补0，  >>> 无符号左移

8、instanceOf运算符用来判断一个变量所引用的对象的实际类型，(重点考察上转型看实际)是否可通过向上或向下转型转换。

9、强制转int型，会向下取整。 int(5.7) = 5

10、String str1 = new String(“hello”);   //正常创建对象保存在堆区

    String str2 =  “Hello”;    //创建的字符串，保存在字符串常量区

11、当使用Integer赋值的时候，java编译器会将其翻译成调用ValueOf()方法，比如 Integer i = 127,对于-128到127之间的数，Java会对其进行缓存，超过这个范围则新建一个对象。

12、 求数组的长度(容量)：length。

   求字符串的长度：length()。

   求集合的长度：size().

13.  Java中的 i=i++ 和 i=++i 问题 : 涉及到 临时变量的问题，会将i的值先存储起来，再做i=i+1，最后将存储起来的i赋值给 i。

14.  如果在定义变量的时候，遇到float a = 10.0 =>会丢失精度，因为小数默认为double。

 正确的写法应该是 float a = 10.0f

各个类型的字节数： 1  2  2  4  8  4  8

15. boolean类型只有两个值 分别是 true 和 false，没有1或者0的说法。

 

 

 

 

// 陌生单词：compile编译、deprecation过时、PermGen永久代(方法区)、Heap堆内存