JavaSE复习之一 基础知识：Java的基础语法

Java的基础语法

1.数据类型

        Java是面向对象的语言，也是强类型语言，变量在使用前需先定义后使用。在Java中共有八种基本类型，包括四种整型、两种
浮点数类型、一种字符类型、一种布尔类型，这八种类型不是对象。除基本类型之外的都叫做对象类型或引用类型。

1.1.整型

        用于表示没有小数部分的数值，可以是负数。Java提供了四种整型数：整型（int）、短整型（short）、长整型（long）、
字节型（ byte）。

1.2.浮点数类型
        用于表示有小数部分的数值。Java提供两种浮点类型：单精度（float）、双精度（double）。其中单精度浮点数占用4个字节，
多精度浮点数占用8个字节。

float f1 = 5.0F;
double d1 = -3.45;

1.3.字符类型

        Java提供字符类型char，用于表示单个字符。对于字符Java采用Unicode字符编码（字符编码是指用一串二进制数据来表示特定
的字符）。 常见的字符编码包括：
1) ASCII字符编码
        美国信息互换标准代码（American Standard Code for Information Interchange）。
        ASCII编码一共能表示128（二的七次方）个字符，是最通用的单字节编码系统。
2) ISO-8859-1字符编码
        又称Latin-1，是国际标准化组织（ISO）为西欧语言的字符制定的编码，用一个字节来为字符编码。
3) GB2312字符编码
       包括了对中文字符的编码，收录了7445个字符，其中汉字6763个，其他符号682个。
4) GBK字符编码
        GBK是对GB2312字符编码的扩展，收录了21886个字符，分为汉字区和图形符号区。汉字区包括21003个字符。
5) Unicode字符编码
        由国际Unicode协会（www.unicode.org）编制，收录了全世界所有语言文字中的字符，是一种跨平台的字符编码。
6) UTF字符编码
        UTF（UCS Transformation Format）字符编码能够把Unicode字符编码转换为操作系统支持的编码。

1.4.布尔类型

        任何一种高级编程语言都会使用布尔类型（boolean），用来进行逻辑判断。布尔类型的变量取值只能是true或false，表示逻辑
上的真和假。
        Java虚拟机对布尔类型的处理：当编译器把Java源代码编译为字节码时，会用int或byte来表示boolean。在JVM中，用整数零来
表示false，用任意一个非零整数来表示true。但在为布尔类型变量赋值时，只能使用true或false。

1.5.数组
        Java把数组当成对象，数组变量相当于对象的引用。
        数组元素的默认值：布尔类型，默认值是false；字符型，默认值是'\u0000'；数值型，默认值是0或0.0；引用类型，默认值null
        数组在使用中经常抛出的异常是：ArrayIndexOutOfBoundsException(数组下标越界异常)；
                                                                    java.lang.NullPointerException(空指针异常)；
        关于数组的工具类：java.util.Arrays(提供让我们对数组进行操作的方法，比如查找、排序);system.arraycppy(实现数组的拷贝)。

        数组声明，实例化，赋初值的方法：

int a[] = new int[5];  // 形式一
a[0] = 10; a[1] = 8;
		
int[] b = new int[5];  // 形式二
		
int[][]c; intc[][];    // 形式三：多维数组

1.6.字符串
        字符串（java.lang.String）对象是public final class的，也叫做断子绝孙类。


1.7.类

        类是一组具有相同属性和行为的对象的抽象。

public abstract class 中国人 {           //  抽象类不能被实例化
        public abstract void 善良();     //  包含抽象方法的类一定是抽象类，抽象方法没有方法体；继承了抽象类的子类若未实现父类的抽象方法，
                                        //  则一定也是抽象类，而非普通类。换句话，普通类继承抽象类，必须实现其抽象方法。
                                        //  再换句话说：所有抽象方法都执行子类中重写后的方法。
        public abstract void 勤劳();     //
        public void 乐于助人(){};        //  抽象类中可以包含非抽象方法
}

public class 小明 extends 中国人 {

	@Override
	public void 善良() {
		System.out.println("善良"); // 
	}

	@Override
	public void 勤劳() {
		System.out.println("勤劳"); // 
	}
}

1.8.接口

        接口是对类的抽象。

public interface 农村孩子 {	
    public static final String HP ="豌豆";   //  接口中的成员变量默认是public static  final类型的，必须被显式初始化
    public abstract void 憨厚();             //  接口中的方法默认都是public  abstract类型的
    public abstract void 老实();             //  接口中只能包含public static final类型的成员变量和public abstract类型的成员方法
    public abstract void 肯吃苦();           //  接口没有有构造方法，不能被实例化；一个接口不能实现另一个接口，可以继承多个其他接口
                                            //  普通类实现接口，必须实现接口的抽象方法；抽象类implements一个接口可以不实现其抽象方法
}

2.变量

        每个变量都是有类型的，需满足先声明后使用的原则。声明变量：变量类型   变量名;

变量名必须是一个以字母开头的由字母或数字构成的序列。字母包括'A'~'Z'、'a' ~'z'、'_'。

2.1.初始化及默认值
变量的默认值：
Boolean    false
Char       '\u0000' =>null
byte       0
short      0
int          0
long       0L
float       0.0f
double   0.0d

public class VarTest {
/**
 * @param args
 */
	private String ss = "aaa";   // 若ss未赋初始值，则在testVar()方法中打印出的是其默认值null
	private int ii;              // JVM会给ii赋值0，从而进行初始化 
	
	public String testVar(){
		
		int t = 1;
		String str;  // 此处未赋值，而又不属于类的成员变量，JVM不会为其进行初始化。所以，在此方法内部使用时编译器会报错
		
		System.out.println(t);
		System.out.println(str); //编译器会报错，提示local variable may not initialized
		System.out.println(ss);
		System.out.println(ii);
		
		return "suc";
	}
	
	public static void main(String args[]){
		VarTest vt = new VarTest();
                vt.testVar();
	}
}

2.2.变量赋值和类型转换
下面的例子只涉及基本类型的类型转换：

    int a;
    a = 10;    // 变量赋值

    String arrayStr[] = {"a","b","c","d"}; //数组赋值

    double d = a;    //自动类型转换（）

    double diu = 4.007;    // 变量赋值
    int aiu = (int)diu;    //强制类型转换
    System.out.println(aiu);    // 打印出的aiu值为4，小数部分丢失

引用类型的类型转换（多态）及基本类型与引用类型的转换（自动装箱）在后面写。

2.3.变量的作用域和生命周期

成员变量和局部变量

3.运算符

        Java语言中的运算符可分为以下几种：算术运算符、赋值运算符、比较运算符、逻辑运算符、位运算符、类型相关运算符。

3.1.运算符

算术运算符：加（+）、减（-）、乘（＊）、除（／）、求余（%）、自增（++）、自减（--）；

赋值运算符：Java使用=作为赋值运算符；
位运算符：与（&）、或（｜）、非（～）、异或（^）、左移运算符（<<）、右移运算符（>>）、无符号右移（>>>）；
比较运算符：大于（>）、大于等于（>=）、小于（<）、小于等于（<=）、等于（==）、不等于（！=）；
逻辑运算符：与（&&）、或（||）、非（!）、异或（^）、不短路与（&）、不短路或（|）；

三目运算符： （表达式）？语句1（表达式为true时执行）：语句2（表达式为false时执行）

运算符的优先级：

3.2.数学函数及常量

        进行乘方、开方等复杂的数学运算，可使用java.lang.Math类提供的工具完成。

4.流程控制

        编程语言常见的三种流程结构：顺序结构、分支结构（选择结构）、循环结构。

4.1.顺序结构
        顺序结构是最常见的程序结构，指程序由上而下逐行执行直至结束。

4.2.分支结构
用于实现根据判断条件来选择性地执行某段代码。
        分支控制结构使部分程序代码有条件的执行。即满足条件才执行，不满足则不执行。

if...else 语句

public void ifelse(){
		
	if ( condition ){      // 形式一
             execute statement
        }


        if ( condition ){      // 形式二
             execute statement1
        }else{
             execute statement2
        }


        if ( condition1 ){    // 形式三
             statement1  
        }else if ( condition2 ){  // 可以有零个或多个else if语句
             statement2
        }else{                    // 此处的else语句可以省略 
             statement3
        }
        
 }

switch 语句

        由一个控制表达式和多个case标签组成。switch语句后面的控制表达式的数据类型只能是byte、short、char、int四个整数类型和
枚举类型，不能是boolean类型。Java7中允许switch语句中的控制表达式为String类型。

public void TestSwitch(){
		
		String condition = "str"; // Java7支持使用String作为表达式的数据类型
		int a =1;
		
		switch ( a ){
		    case 0: {System.out.println(a); break; }
		    case 1: {System.out.println(a); break; }
		    case 2: {System.out.println(a); break; }
		    case 3: {System.out.println(a); break; }
		    
		    default:{System.out.println("default"); }  
		}

	}

4.3.循环结构
用于实现根据循环条件重复执行某段代码。

        循环控制结构使部分程序代码反复、重复执行，直到不满足循环条件为止才退出循环。

while (循环条件) {循环体}

public void TestWhile(){
		
	int count = 10; // 循环的初始化条件
		
	while (count > 0){  // 当count小于10时，执行循环体
	    System.out.print(count+"  "); // 迭代语句
	    count--;
	    }
        }
	
	public static void main(String args[]){
	    FlowCo  fc = new FlowCo();
	    fc.TestWhile();
	}

        // 输出：10  9  8  7  6  5  4  3  2  1 

do{循环体}while(循环条件)

public void TestDoWhile(){

    int coo = 10;
        do{
            System.out.print(coo+"  "); // 循环语句
	    coo--;

          }while (coo > 0);    // 判断条件，即跳出循环的条件

    }

    public static void main(String args[]){
        FlowCo  fc = new FlowCo();
	fc.TestDoWhile();

 }

        // 输出：10  9  8  7  6  5  4  3  2  1 

for(初始化部分;循环条件;迭代部分){循环体}

public void TestFor(){
		
    for(int cc=1;cc<10;cc++){ // for(初始条件;循环条件;步进)

      System.out.println(cc); // 循环语句块

    }
}

For  Each循环：for(变量 ：集合 )   循环语句

public void TestForEach(){
		
    List<String> list = new ArrayList<String>();
    list.add("zhaobenshan");
    list.add("zhaobenshui");
    list.add("zhaosi");
		
        for (String s:list){  // 
	  System.out.println(s);
	}
    }

public static void main(String args[]){
    FlowCo  fc = new FlowCo();
    fc.TestForEach();	
}

4.4.流程跳转

        控制程序执行顺序。

break ：从switch语句、循环语句或标号标识的代码块中退出。break不仅可以结束其所在的循环，还可以结束其外层循环。

continue ：跳出本次循环，执行下一次循环，或执行标号标识的循环体。

return ：退出本方法，跳到上一层。

5.数组

5.1.数组的初始化

静态初始化：

String[] strA = {"kali","ubuntu","fedora","centos","suse"};
  for(int i=0;i<strA.length;i++){ System.out.println(strA[i]); }

动态初始化 ：

String[] strB = new String[10];
    for(int i=0;i<10;i++){
        strB[i] = i+"";
    }
  for(int i=0;i<strB.length;i++){ System.out.println(strB[i]); }

5.2 数组的操作









修订：

参考：

注：