（一）Java基础巩固

抽象类：

抽象类遵循的原则：

（1）abstract关键字只能修饰类和方法，不能修饰字段。

（2）抽象类不能被实例化（无法使用new关键字创建对象实例），只能被继承。

（3）抽象类可以包含属性，方法，构造方法，初始化块，内部类，枚举类，和普通类一样，普通方法一定要实现，变量可以初始化或不初始化但不能初始化后在抽象类中重新赋值或操作该变量（只能在子类中改变该变量）。

（4）抽象类中的抽象方法（加了abstract关键字的方法）不能实现。

（5）含有抽象方法的类必须定义成抽象类。

 

 

扩展：抽象类和接口的区别，做个总结吧：

（1）接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类是可以有私有方法或私有变量的。

（2）abstract class 在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface，实现多重继承。接口还有标识（里面没有任何方法，如Remote接口）和数据共享（里面的变量全是常量）的作用。

（3）在abstract class 中可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface中，只能够有静态的不能被修改的数据成员（也就是必须是 static final的，不过在 interface中一般不定义数据成员），所有的成员方法默认都是 public abstract 类型的。

（4）abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"is-a"关系，interface表示的是"has-a"关系。

（5）实现接口的一定要实现接口里定义的所有方法，而实现抽象类可以有选择地重写需要用到的方法，一般的应用里，最顶级的是接口，然后是抽象类实现接口，最后才到具体类实现。抽象类中可以有非抽象方法。接口中则不能有实现方法。

（6）接口中定义的变量默认是public static final 型，且必须给其初值，所以实现类中不能重新定义，也不能改变其值。抽象类中的变量默认是 friendly 型，其值可以在子类中重新定义，也可以在子类中重新赋值

一：java概述：

Java的三种技术架构: 

JAVAEE：Java Platform Enterprise Edition，开发企业环境下的应用程序，主要针对web程序开发；

JAVASE：Java Platform Standard Edition，完成桌面应用程序的开发，是其它两者的基础；

JAVAME：Java Platform Micro Edition，开发电子消费产品和嵌入式设备，如手机中的程序；

Java命令的作用：

Java分为两部分：一个是编译，一个是运行。

Javac:负责的是编译部分，当执行javac时，会启动java编译器程序，对.java文件进行编译。形成jvm可以识别的的字节码文件

Java:负责执行部分，会启动jvm对于javac变异的.class文件进行执行。

 

二.Java语法基础：

1.关键字:Java语言赋予特殊含义的单词：

Java 关键字列表 (依字母排序 共51组):

2.保留字：Java预留的关键字

Java 保留字列表 (依字母排序 共14组) :

byValue, cast, false, future, generic, inner, operator, outer, rest, true, var ，goto ，const,null 

3.标识符：自定义名称，类名，变量名，函数名包含0-9，a-z,&,_;

1):数字不能开头

2):不可以使用关键字

4.常量与变量：

1):常量程序中不可变化的数据。作用：代表常数，便于程序的修改，增加可读性

Java语法中：常量首先声明，然后在赋值，但是只能赋值一次。需要在变量前面添加Final关键字

常量名必须大写。

2):变量代表程序的状态。变量在使用必须首先声明，格式：数据类型 变量名称 = 值；变量必须初始化才可用。

※final详情：

设计需求：有些情况必须使用Final关键字，比如方法中匿名内部类的参数传递

final成员变量表示常量，只能被赋值一次。赋值后不可以在变。

列：Final StringBuffer str = new StringBuffer("hello world");

当：str = new StringBuffer("");则报错，当str.append("aa");则可以编译

Final方法不能被子类修改，但是可以继承。

Final类不能被技能，没有子类，Final类所有方法都是Final.如String类。

在接口(interface)里变量都是public static final。

变量的作用域和生存期：

　　变量的作用域：作用域从变量定义的位置开始，到该变量所在大括号结束。

　　生命周期:在他定义的位置在内存中，到作用域结束在内存中消失。

5：数据类型

1):基本数据类型：byte、char、short为平级、int、float、long、double、Boolean

2):引用数据类型：数组，类，接口。

Boolean类型数据只能为true或false。默认值为false，但是必须初始化才能使用。

Char类型用单引号''包括起来单个字符。Java字符蚕蛹Unicode编码。默认值：'u0000'

整数型(Byte、Short、int、long)

浮点数(float、double)Java浮点型常量默认为Double型，如果声明Float需在数字后家F

6：运算符号

算数运算符、关系运算符、逻辑运算符、位运算符。

算数运算符：+  -  *  /  %  ++  --

public class Test003 {
    public static void main(String[] args) {
        int i = 5;
        System.out.println(i++);    //5
        System.out.println(++i);    //7
        System.out.println(i);    //7
        System.out.println(--i);    //6
        System.out.println(i--);    //6
        System.out.println(i);    //5
    }
}

关系运算符：==  !=  >  >=  <  <= 

对应java的基本数据类类型：Integer、Float、Boolean、Character、Double、Short、Byte、Long

1):数值计算中语法现象——“晋升”，即：byte、short和char(低于int的数据类型)进行算术运算后，结果会自动提升成int类型；
2):两个char型运算时，自动转换为int型；当char与别的类型运算时，也会先自动转换为int型的，再做其它类型的自动转换；
3):算数运算可以加入小括号"()"提高优先级，优先小括号内运算，再其他运算符运算；
4):算数运算前操作数变量必须赋值，反之，报语法错误。

逻辑运算符：&&  ||  !  ^  &  |

public class Test003 {
    public static void main(String[] args) {
        boolean t = true;
        boolean f = false;
        System.out.println(t && f);    //false，短路与运算符，若运算符左侧为false则不计算右侧的表达式
        System.out.println(t || f);    //true，短路或运算符，若运算符左侧为true则不计算右侧的表达式
        System.out.println(t & f);    //false，与运算符，不管左侧是否为false都要计算右侧的表达式
        System.out.println(t | f);    //true，或运算符，不管左侧是否为true都要计算右侧的表达式
        System.out.println(t ^ f);    //true，异或运算符，只要左右两侧不相同则为true，反之为false
        System.out.println(!f);    //true，取反运算符
    }
}

位运算符：&  |  ~  ^  >>  <<  >>>

public class Test003 {
    public static void main(String[] args) {
        //在位运算符中1相当于true，0相当于false
        int b1 = 6;    //二进制为00000000 00000000 00000000 00000110
        int b2 = 11;    //二进制为00000000 00000000 00000000 00001011
        System.out.println(b1 & b2);    //按位与运算符，二进制为00000000 00000000 00000000 00000010，结果为2
        System.out.println(b1 | b2);    //按位或运算符，二进制为00000000 00000000 00000000 00001111，结果为15
        System.out.println(b1 ^ b2);    //按位异或运算符，二进制为00000000 00000000 00000000 00001101，结果为13
        System.out.println(~b1);    //按位取反运算符，二进制为11111111 11111111 11111111 11111001，结果为-7
        System.out.println(b1 << 2);    //左移位运算符，二进制为00000000 00000000 00000000 00011000，结果为24
        int b3 = -14;    //二进制为11111111 11111111 11111111 11110010
        System.out.println(b3 >> 2);    //带符号右移位运算符，二进制为11111111 11111111 11111111 11111100，结果为-4
        System.out.println(b3 >>> 2);    //无符号右移位运算符，二进制为00111111 11111111 11111111 11111100，结果为1073741820
    }
}

条件运算符(三目运算符)：<表达式1> ？<表达式2> : <表达式3>

int a = 55,b = 132,res;  
res = a > b ? a : b;  
System.out.println(res);  

字符串（+）运算符：当操作数是字符串时，加（+）运算符用来合并两个字符串；当加（+）运算符的一边是字符串，另一边是数值时，机器将自动将数值转换为字符串，并连接为一个字符串。

String a ="aa";  
int c = 555;  
String b = a+"bbb"+c;  
System.out.println(b);  
结果：aabbb555

对象运算符instanceof：对象运算符instanceof用来测试一个指定对象是否是指定类（或它的子类）的实例，若是则返回true，否则返回false。

String s = new String("sa");  
if(s instanceof Object){  
    System.out.println("String is object class");  
}  

8. 一维数组

public class Test003 {
    public static void main(String[] args) {
        int[] i;    //声明一个整型的一维数组变量
        int ii[];    //声明一个整型的一维数组变量
        i = new int[5]; //创建一个长度为5的一维数组对象，并将变量i指向该对象
        float[] f = new float[5];    //直接创建一个长度为5的单精度浮点型一维数组对象，并将变量f指向该对象
        double[] d = {1, 2, 3.4, 4.5};    //直接初始化一个一维数组元素
        
        System.out.println(d[3]);    //通过数组下标来获取数组内的元素，数组下标从0开始，结果为4.5
        System.out.println(f[0]);    //当创建出一个数组对象时，该对象内的数组元素为该数据类型的默认值，所以此处结果为0.0
        System.out.println(i[5]);//当通过数组下标来获取数组内元素时，[]内的值>=数组长度则报异常java.lang.ArrayIndexOutOfBoundsException（数组下标越界）
        System.out.println(ii[0]);    //若一个数组变量只声明而未指向某一个具体的数组对象时，编译出错
        System.out.println(d.length);    //得到该数组的长度，结果为4
    }
}

10. 二维数组

public class Test003 {
    public static void main(String[] args) {
        int[][] i;    //声明一个整型的二维数组变量
        int ii[][];    //声明一个整型的二维数组变量
        int[] iii[];    //声明一个整型的二维数组变量
        i = new int[5][2]; //创建一个长度为5的二维数组对象，并将变量i指向该对象
        float[][] f = new float[5][2];    //直接创建一个长度为5的单精度浮点型二维数组对象，并将变量f指向该对象
        double[][] d = {{1}, {2,3}, {4,5,6}, {7,8,9,10}};    //直接初始化一个二维数组元素
        
        System.out.println(d[3][1]);    //通过数组下标来获取数组内的元素，数组下标从0开始，结果为8
      　System.out.println(f[0][0]);    //当创建出二个数组对象时，该对象内的数组元素为该数据类型的默认值，所以此处结果为0.0
     System.out.println(i[5][0]);//当通过数组下标来获取数组内元素时，[]内的值>=数组长度则报异常java.lang.ArrayIndexOutOfBoundsException（数组下标越界）
        System.out.println(ii[0][0]);    //若一个数组变量只声明而未指向某一个具体的数组对象时，编译出错
        System.out.println(d.length);    //得到该数组的长度，结果为4
        System.out.println(d[2].length);    //得到二位数组内的下标为2的那个一维数组的长度
    }
}

流程控制语句（if,switch,for,while,do...while）

11.条件分支语句

public class Test003 {
    public static void main(String[] args) {
        int[] score = new int[5];
        score[0] = -7;
        score[1] = 65;
        score[2] = 80;
        score[3] = 90;
        score[4] = 59;
        for(int i=0; i<score.length; i++) {
            if(score[i]>=0 && score[i]<60) {
                System.out.println("不及格");
            }else if(score[i]>=60 && score[i]<80) {
                System.out.println("及格");
            }else if(score[i]>=80 && score[i]<90) {
                System.out.println("良");
            }else if(score[i]>=90 && score[i]<100) {
                System.out.println("优");
            }else {
                System.out.println("成绩异常");
            }
        }
        char ch = 'a';
        switch(ch) {    //switch括号内只支持 byte,short,int,char,enum五种数据类型，但是JDK1.7版本增加了String类型，所以相对于JDK1.7而言就是六种了
            case 'A':    //case为switch语句的入口，break为出口，从入口开始执行，直到遇到出口或代码执行完毕才结束
            case 'a':
                System.out.println("优");
                break;
            case 'B':
            case 'b':
                System.out.println("良");
                break;
            case 'C':
            case 'c':
                System.out.println("及格");
                break;
            default:    //若上述条件均不匹配，则进default开始执行语句
                System.out.println("不及格");
        }
    }
}

12. 循环语句

public class Test003 {
    public static void main(String[] args) {
        int res = 0;
        out:    //out是一个标号，告诉java从哪里开始执行程序
        for(int i=1; i<=10; i++) {
            if(i==3) continue out;    //continue终止本次循环，执行下次循环
            if(i==5) break out;    //break跳出循环
            res = res + i;
        }
        System.out.println(res);    //结果为1+2+4=7
        
        int res2 = 0;
        int i = 1;
        in:
        do{
            if(i==3) continue in;    //continue终止本次循环，执行下次循环
            if(i==5) break in;    //break跳出循环
            res2 = res2 + i;
            i++;
        }while(i<=10);
        System.out.println(res2);
    }
}