JAVA 基础

1. Java数据类型

        Java是强类型语言，所有的变量必须先声明后使用，定义变量需要显示的声明一个在编译时就能确定的类型。
        Java中的数据类型有两种，基本类型（Primitive Type）和引用类型（Reference Type）。
        1）基本数据类型

        Java基本类型分为两类：数值型和布尔型。数值型可分为整型以及浮点型，整形中的字符型也可单独分为一类。所以一般把基本类型分为4类，如下表：

分类	类型	长度
整数型	int	32位
	long	64位
	short	16位
	byte	8位
字符型	char	16位
浮点型	double	64位
	float	32位
布尔型	boolean	1位

        ①整型：int为最常用的整型变量。系统中的整数常量会被看作int处理。但有以下两个例外：

• 如果一个整数很小（在byte或short）的范围内，当这个整数常量被付给一个byte或short变量时，整数常量会被当作byte或short类型。
• 如果一个巨大的整数常量(超出了Int的存储范围)时，系统不会把这个整数当作long类型处理，除非用户在常量后加上一个字母"L"。

        示例：

[java] view plain copy

1. public class IntegerValTest {  
2.     public static void main(String[] args) {  
3.         //下面代码是正确的，系统会自动把56当成byte类型处理  
4.         byte a = 56;  
5.         /* 
6.         下面代码是错的，系统不会把9999999999999当成long类型处理， 
7.         所以超出int的表数范围，从而引起错误 
8.         */  
9.         //long bigValue = 9999999999999;  
10.         //下面代码是正确的，在巨大的整数常量后使用L后缀，强制使用long类型  
11.         long bigValue2 = 9223372036854775807L;  
12.       
13.         //以0开头的整数常量是8进制的整数  
14.         int octalValue = 013;  
15.         System.out.println(octalValue);  
16.         //以0x或0X开头的整数常量是16进制的整数  
17.         int hexValue1 = 0x13;  
18.         int hexValue2 = 0XaF;  
19.   
20.   
21.         System.out.println(hexValue1);  
22.         System.out.println(hexValue2);  
23.   
24.   
25.         // 定义二个8位的二进制数  
26.         int binVal1 = 0b11010100;  
27.         byte binVal2 = 0b01101001;  
28.         // 定义一个32位的二进制数,最高位是符号位。  
29.         int binVal3 = 0B10000000000000000000000000000011;  
30.         System.out.println(binVal1); // 输出212  
31.         System.out.println(binVal2); // 输出105  
32.         System.out.println(binVal3); // 输出-2147483645  
33.         /* 
34.          定义一个8位的二进制，该数值默认占32位，因此它是一个正数。 
35.          只是强制类型转换成byte时产生了溢出，最终导致binVal4变成了-23 
36.          */  
37.         byte binVal4 =  (byte)0b11101001;  
38.         /* 
39.           定义一个32位的二进制数,最好位是符号位。 
40.           但由于数值后添加了L后缀，因此该整数的实际占64位，第32位的1不是符号位。 
41.           因此binVal5的值等于2的31次方 + 2 + 1 
42.          */  
43.         long binVal5 = 0B10000000000000000000000000000011L;  
44.         System.out.println(binVal4); // 输出-23  
45.         System.out.println(binVal5); // 输出2147483651  
46.     }  
47. }  

        ②字符型
        字符型用于表示耽搁的字符。字符常量通常用单引号(')括起来。Java使用unicode编码方式，所以字符型变量能够表示大部分国家的文字字符。
        字符表示有以下几种方式：

• 直接使用字符常量：如 ‘a’、'我'等。
• 使用转移字符：如'\n'、'\t'等。
• 使用unicode表示字符：如'\uxxxx'，其中x表示一个十六进制整数。

        如果把一个整数（0~65535之间）常量赋给字符类型变量，系统会把整数当作char处理。       

        示例：

[java] view plain copy

1. public class CharTest {  
2.     public static void main(String[] args) {  
3.         //直接指定单个字符作为字符常量  
4.         char aChar = 'a';  
5.         //使用转义字符来作为字符常量  
6.         char enterChar = '\r';  
7.         //使用Unicode编码值来指定字符常量  
8.         char ch = '\u9999';  
9.         //将输出一个'香'字符  
10.         System.out.println(ch);  
11.         // 定义一个'疯'字符常量  
12.         char zhong = '疯';  
13.         // 直接将一个char变量当成int类型变量使用  
14.         int zhongValue = zhong;  
15.         System.out.println(zhongValue);  
16.         //直接把一个0～65535范围内的int整数赋给一个char变量  
17.         char c = 97;  
18.         System.out.println(c);  
19.     }  
20. }  

        ③浮点型
        Java中浮点型有两种：double和float，两个浮点型的长度分别为64位和32位，且长度不因环境的改变而改变。浮点数的特点是不能够精确的表示一个小数位数较多的小数。
        浮点数有两种表示方式：

• 十进制表示：3.11、5.2、4等
• 科学计数法表示：4.12E3、5.12E2；

        java中一个浮点数常量默认为double类型，如果要系统把一个小数常量当作float处理，需要在小数后加上f字母。
        示例：

[java] view plain copy

1. public class FloatTest {  
2.     public static void main(String[] args) {  
3.         float af = 5.2345556f;  
4.         //下面将看到af的值已经发生了改变  
5.         System.out.println(af);  
6.         double a = 0.0;  
7.         double c = Double.NEGATIVE_INFINITY;  
8.         float d = Float.NEGATIVE_INFINITY;  
9.         //看到float和double的负无穷大是相等的。  
10.         System.out.println(c == d);  
11.         //0.0除以0.0将出现非数  
12.         System.out.println(a / a);  
13.         //两个非数之间是不相等的  
14.         System.out.println(a / a == Float.NaN);  
15.         //所有正无穷大都是相等的  
16.         System.out.println(6.0 / 0 == 555.0/0);  
17.         //负数除以0.0得到负无穷大  
18.         System.out.println(-8 / a);  
19.         //下面代码将抛出除以0的异常  
20.         //System.out.println(0 / 0);  
21.     }  
22. }         

        ④布尔型
        布尔型只有一个boolean类型，用于表示逻辑真或者逻辑假。boolean的值只能为true或者是false，其他基本类型不能转换到boolean类型。
        示例：

[java] view plain copy

1. public class BooleanTest {  
2.     public static void main(String[] args) {  
3.         boolean b1 = true;  
4.         boolean b2 = false;  
5.         //下面代码将出现错误：字符串不能直接变成boolean型的值  
6.         //boolean b3 = "true";  
7.         //使用boolean和字符串进行连接运算，boolean会自动转换成字符串  
8.         String str = true + "";  
9.         //下面将输出true  
10.         System.out.println(str);  
11.     }  
12. }      

        2）基本类型之间的转换
        Java中基本类型有两种转换方式自动转换和强制转换。讲一个表数范围小的变量赋给一个表数范围大的变量，系统将进行自动转换，将小便量转换为大变量在进行赋值操作。
        示例：

[java] view plain copy

1. public class AutoPromote {  
2.     public static void main(String[] args) {  
3.         //定义一个short类型变量  
4.         short sValue = 5;  
5.         //下面代码将出错：表达式中的sValue将自动提升到int类型，  
6.         //则右边的表达式类型为int，将一个int类型赋给short类型的变量将发生错误。  
7.         //sValue = sValue - 2;  
8.         byte b = 40;  
9.         char c = 'a';  
10.         int i = 23;  
11.         double d = .314;  
12.         //右边表达式中在最高等级操作数为d（double型）  
13.         //则右边表达式的类型为double型,故赋给一个double型变量  
14.         double result = b + c + i * d;  
15.         //将输出144.222  
16.         System.out.println(result);  
17.         int val = 3;  
18.         //右边表达式中2个操作数都是int，故右边表达式的类型为int  
19.         //因此，虽然23/3不能除尽，依然得到一个int整数  
20.         int intResult = 23 / val;  
21.         //将输出7  
22.         System.out.println(intResult);  
23.         //输出字符串Hello!a7  
24.         System.out.println("Hello!" + 'a' + 7);  
25.         //输出字符串104Hello!  
26.         System.out.println('a' + 7 + "Hello!");  
27.   
28.   
29.     }  
30. }    

        如果系统把大范围变量转换为小范围变量就需要强制转换，强制转换的语法格式是(type)value，可将valae强制转换为type类型的变量。当强制转换可能会导致数据精度的丢失，请看示例：

[java] view plain copy

1. public class NarrowConversion {  
2.     public static void main(String[] args) {  
3.         int iValue = 233;  
4.         //强制把一个int类型的值转换为byte类型的值  
5.         byte bValue = (byte)iValue;  
6.         //将输出-23  
7.         System.out.println(bValue);  
8.         double dValue = 3.98;  
9.         //强制把一个double类型的值转换为int  
10.         int tol = (int)dValue;  
11.         // 将输出3  
12.         System.out.println(tol);  
13.     }  
14. }         

        3）表达式类型的自动提升
        当一个算术表达式中包含多个基本类型时，整个表达式的类型会发生自动提升，Java定义了如下的提升规则：

• 所有的byte类型，short类型和char经提升到int类型。
• 怎个算术表达式的数据类型提升到最高等级操作时的类型。

        示例：

[java] view plain copy

1. public class AutoPromote {  
2.     public static void main(String[] args) {  
3.         //定义一个short类型变量  
4.         short sValue = 5;  
5.         //下面代码将出错：表达式中的sValue将自动提升到int类型，  
6.         //则右边的表达式类型为int，将一个int类型赋给short类型的变量将发生错误。  
7.         //sValue = sValue - 2;  
8.         byte b = 40;  
9.         char c = 'a';  
10.         int i = 23;  
11.         double d = .314;  
12.         //右边表达式中在最高等级操作数为d（double型）  
13.         //则右边表达式的类型为double型,故赋给一个double型变量  
14.         double result = b + c + i * d;  
15.         //将输出144.222  
16.         System.out.println(result);  
17.         int val = 3;  
18.         //右边表达式中2个操作数都是int，故右边表达式的类型为int  
19.         //因此，虽然23/3不能除尽，依然得到一个int整数  
20.         int intResult = 23 / val;  
21.         //将输出7  
22.         System.out.println(intResult);  
23.         //输出字符串Hello!a7  
24.         System.out.println("Hello!" + 'a' + 7);  
25.         //输出字符串104Hello!  
26.         System.out.println('a' + 7 + "Hello!");  
27.     }  
28. }  

2. Java数组的使用

        数组是编程语言中最常见的一种数据结构，可以存储多了元素，通常可以通过数组元素的索引来访问数组元素，包括为数组元素赋值和取出数组元素的值。


        1）数组也是一种类型

• Java中数组要求所包含的元素必须是同一数据类型。在一个数组中，元素的类型时唯一的。一单数组被初始化后，它在内存中占用的空间就确定了，不管数组中是否存放了元素。
• Java的数组也是一种数据类型，是一种引用类型，例如int是一个基本类型，但int[]就是一个引用类型了。

        2）定义数组‘
        可以使用两种方式定义数组

• type[] arrayName;
• type arrayName[];

        推荐使用第一种，更加突出数组是一种数据类型。

        3）数组的初始化
        Java中的变量都必须先初始化才可以使用。所谓初始化，就是为数组的元素分配内存空间并为每个元素赋初值。
        注意：只要为数组元素分配了内存空间，那么元素就一定有一个初始值。
        数组的初始化有如下两种方式：

• 静态初始化：初始化时用户显示的指定每个数组元素的初始值，由系统决定数组长度。
• 动态初始化：初始化中用户指定数组长度，由系统为元素分配初始值。

        静态初始化的语法如下：

        arrayName = new type[]{element1, element2, element3...}
        type是数组中元素的类型，等号后面的type类型只能是前面和前面type的类型相同或是其子类。
        示例：

[java] view plain copy

1. //定义一个int数组类型的变量，变量名为intArr.  
2. int[] intArr;  
3. //使用静态初始化，初始化数组时只指定数组元素的初始值，不指定数组长度。  
4. intArr = new int[]{5, 6, 8, 20};  
5. //定义一个Object数组类型的变量，变量名为objArr.  
6. Object[] objArr;  
7. //使用静态初始化，初始化数组时数组元素的类型是  
8. //定义数组时数组元素类型的子类  
9. objArr = new String[]{"Java" , "张三"};  
10. Object[] objArr2;  
11. //使用静态初始化  
12. objArr2 = new Object[] {"Java" , "张三"};  

        除此之外，静态初始化还有如图下的语法格式：
        arrayName = {element1, element2, element3...}
        在这种语法格式中，直接使用花括号定义第一数组：例如

[java] view plain copy

1. //数组的定义和初始化同时完成，使用简化的静态初始化写法  
2. int[] a = {5, 6 , 7, 9};     

        动态初始化：
        动态初始化只指定数组的长度，由系统默认为数组元素赋初值，格式如下：
        arrayName = new type[length];
        示例：

[java] view plain copy

1. //数组的定义和初始化同时完成，使用动态初始化语法  
2. int[] prices = new int[5];  
3. //数组的定义和初始化同时完成，初始化数组时元素的类型是定义数组时元素类型的子类  
4. Object[] books = new String[4];  

        系统在分配元素的初值时，按一下规则：

• 如元素为基本类型中的整型，默认值为 0；
• 如是基本类型中的浮点型，默认值为 0.0；
• 如实基本类型中的字符型，默认值为 '\u0000'；
• 如实基本类型中的布尔型，默认值为 false；
• 如是引用类型，默认值为 null；

        4）使用数组
        创建一个数组后，可通过数组下表访问（从0开始），可使用for循环来遍历数组元素，也可使用更简洁的foreach进行遍历。
        示例:

[java] view plain copy

1. public class ForEachErrorTest {  
2.     public static void main(String[] args)  {  
3.         String[] books = {"高等数学" ,   
4.         "大学英语",  
5.         "大学物理"};  
6.         //使用foreach循环来遍历数组元素，其中book将会自动迭代每个数组元素  
7.         for (String book : books)  
8.         {  
9.             book = "高等数学";  
10.             System.out.println(book);  
11.         }  
12.         System.out.println(books[0]);  
13.     }  
14. }  

        注意：使用foreach遍历数组时，不能改变数组元素的值，所以不要对foreach的循环变量进行赋值。


        5）深入数组
        数组变量是引用类型，它指向内存中数组区域的第一个元素。数组元素和数组变量在内存中是分开存放的。实际的数组对象存储在堆内存中，如果引用该数组的引用变量是一个局部变量，那么它被存放在栈内存中。如下图所示：

        如果堆内存中不在有任何的引用变量指向自己，则这个数组将成为垃圾，等待垃圾回收机制回收。因此，为了将一个数组回收，可将数组引用变量赋值为null。，切断其与数组之间的联系。
        只要类型相互兼容，就可以让一个数组指向另一个实际的数组，如下所示：

[java] view plain copy

1. public class ArrayInRam {  
2.     public static void main(String[] args) {  
3.         //定义并初始化数组，使用静态初始化  
4.         int[] a = {5, 7 , 20};  
5.         //定义并初始化数组，使用动态初始化  
6.         int[] b = new int[4];  
7.         //输出b数组的长度  
8.         System.out.println("b数组的长度为：" + b.length);  
9.         //循环输出a数组的元素  
10.         for (int i = 0 ,len = a.length; i < len ; i++ ) {  
11.             System.out.println(a[i]);  
12.         }  
13.         //循环输出b数组的元素  
14.         for (int i = 0 , len = b.length; i < len ; i++ ) {  
15.             System.out.println(b[i]);  
16.         }  
17.         //因为a是int[]类型，b也是int[]类型，所以可以将a的值赋给b。  
18.         //也就是让b引用指向a引用指向的数组  
19.         b = a;  
20.         //再次输出b数组的长度  
21.         System.out.println("b数组的长度为：" + b.length);  
22.     }  
23. }  

3、封装

       1)private私有；

       2)public  公有；（set设置、get查看）

       3)static修饰符

       static可以修饰成员变量和成员函数

        ①static成员变量：

• 被所有对象共享，只有一份副本
• 通过“对象名”或“类名”都可以访问
• static的成员变量是在当我们第一次使用该类时，首先被存储在静态区内。在没有此类对象的情况下，就已经存在了。
• 静态成员变量只有一份拷贝，任何对象修改后，其他对象看到的都是新值

        2）static 成员函数

• 可以将一个方法声明为static
• 静态方法在没有类对象的情况下就产生了
• 可以通过类名调用，也可以通过对象名调用
• 静态的方法不能访问非静态的成员变量。因为静态方法在没有对象存在的情况下就已经先期存在，但是此时没有任何对象存在，也就没有对象的成员变量空间和值，所以，无法访问

          static成员函数应用：

• 经常在一个类中定义若干多的静态方法，例如：求三个数的最大值，还有对数组排序等等
• 供整个项目共享，通过类名可以直接使用

        3）static(静态)初始化代码块

• 使用static定义代码块，当第一次使用该类、或访问该类成员时，执行一次,     且只执行一次
• 静态初始化代码块只能访问静态成员变量、调用静态成员方法

4. 继承extends

       1.当我们面向对象设计时，会发现一些已抽取的类中，有一些相同的属性或方法。这时我们可以对这些具有重复属性或方法的类进行进一步抽取。

       2.将抽取后的类，作为基类，可以被其他类“继承”，达到一个“重用” 的目的

       3.一个类“继承”其他类，使用关键字extends

        继承的特点：

• Java只支持单继承，不支持多继承
• Java允许多级继承
• 不要仅为了获取其他类中某个功能而去继承

       类与类之间的关系：（UML）

       1.继承关系(is a)（一般关系）：子类继承父类

       2.关联关系(has a有一个,多个)：例如:学员类和科目类(学员要有一个科目)

       3.组合关系：一个类，有多个其他类组成的。

       4.依赖关系：一般在类中不持有另外一个类的引用，但是某些方法需要另外类型的引用 这时、这个类依赖于参数类

        Super关键字/函数的重写

       1.子类定义了跟父类同名的成员变量，这时、这个变量将覆盖(隐藏)了父的同名变量

       2.在子类中，可以使用super关键字显示的调用父类被隐藏的成员变量

       访问修饰符：private(私有的)-> 默认 ->protected(受保护的)->public(公共的)

       函数的重写(Override)(覆盖、重写)

      

       1.子类中可以出现跟父类一样的方法，这时就是:函数的重写

         1).返回值类型 方法名参数列表：完全相同

         2).访问修饰符：子类重写父类的方法时，访问修饰符必须同重写的方法一致，或更宽的访问修饰符(不包括private)

            2.1).编译时，检查如果方法名、参数列表相同，返回值不同将出现编译错误

               2.2).如果返回值类型、方法名相同，参数列表不同，可以编译运行， 这个是子类特有的方法，和父类show()方法没有关系

 

       2.private方法不能被重写：

         1).子类可以定义一个和父类相同的private的方法，但这不是“重写”， 各自独立的。(即两边都是私有的)

5. 多态

       多态的特点

       1.成员变量:父类访问的变量始终是父类自己的（对于父类自己的变量及被覆   盖的变量）

       2.成员方法:编译的时候看父类中是否有方法，如果没有，编译错误,运行的时候是子类的方法

       3.静态方法:被覆盖的静态成员，访问的是父类的。一般情况下，多态性访问的都是父类的，父类有，则编译通过，否则编译失 败 有一个特殊，对于被覆盖的成员方法，运行时是子类的，父类引用，不能访问子类特有的成员