JavaSE复习笔记

Java语言概述

基础常识：

Java语言的特性：面向对象性、健壮性、跨平台性。

常用的DOS命令：

• dir : 列出当前目录下的文件以及文件夹
• md : 创建目录
• rd : 删除目录
• cd : 进入指定目录
• cd.. : 退回到上一级目录
• cd\: 退回到根目录
• del : 删除文件
• exit : 退出 dos 命令行

新建文件： echo javase>1.doc

注：rd用来删除目录，del用来删除文件，del后跟的如果是目录名则表示删除该目录下的所有文件（删除前会有确认提示）。若文件夹不为空，rd将不能删除成功。删除同一类型的文件可用通配符，如删除一个文件夹下的所有doc文件：del *.doc。

Java的两种核心机制：Java虚拟机；垃圾收集机制。

JDK(Java Development Kit Java开发工具包)
JRE(Java Runtime Environment Java运行环境)

JVM、JRE与JDK的关系：

因为JVM包含在JDK中，不同的操作系统的JVM不同，因此不同的操作系统需要安装的JDK也不同。

编译：javac HelloWorld.java
生成HelloWorld.class字节码文件
运行：java HelloWorld（不加.class）

一个原文件中可存在多个class，但最多只能有一个public class（也可以没有），且该class名称与原文件名称相同（若没有public class，则源文件可任意命名）。编译后每一个 class分别生成一个.class文件。

Java中的注释类型：

单行注释：//注释文字
多行注释：/*注释文字*/
文档注释：（Java特有）

/**
 *@author 指定Java程序的作者
 *@version 指定源文件的版本
 */

多行注释中可嵌套单行注释，但不可以嵌套多行注释。

文档注释内容可以被JDK提供的工具 javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档。
操作方式： javadoc -d mydoc -author -version HelloWorld.java

生成的mydoc文件中的index.html如图：

---

基本语法：

1.关键字与标识符

Java保留字：现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标记符时要避免使用这些保留字。

byValue、cast、future、 generic、 inner、 operator、 outer、 rest、 var 、 goto 、const

定义合法标识符规则：

• 由26个英文字母大小写，0-9 ，_或 $ 组成。
• 数字不可以开头。
• 不可以使用关键字和保留字，但能包含关键字和保留字。
• Java中严格区分大小写，长度无限制。
• 标识符不能包含空格。

注意：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。

Java中的名称命名规范：

• 包名：多单词组成时所有字母都小写：xxxyyyzzz
• 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
• 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
• 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

2.变量

java的整型常量默认为 int 型，声明long型常量，需要在后面加‘l’或‘L’；Java 的浮点型常量默认为double型，声明float型常量，需要在后面加‘f’或‘F’。

char 型数据用来表示通常意义上的“字符”(2字节)。
字符型常量的三种表现形式：

• 字符常量是用单引号(‘ ’)括起来的单个字符，涵盖世界上所有书面语的字符。例如：char c1 = ‘a’; char c2 = ‘中’; char c3 = ‘9’;
• Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。例如：char c3 = '\n'; // '\n'表示换行符
• 直接使用 Unicode 值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数。如：\u000a 表示 \n。

char类型是可以进行运算的。因为它都对应有Unicode码。

自动类型转换提升顺序：char, byte, short ==>int==>long==>float==>double

当byte, char, short之间做运算时，默认的结果为int类型（即使是同类型的之间做运算也是如此）。

自动类型转换：容量小的类型转换为容量大的类型。
强制类型转换：容量大的类型转换为容量小的类型，需要使用强制类型转换符——（）。

字符串与基本数据类型之间的运算：只能是连接运算”+“。得到的结果仍然是字符串。

String str = "hello";
int i = 123;
char c = 'a';
System.out.println(str + i + c);//hello123a
System.out.println(i + str + c);//123helloa
System.out.println(i + c + str);//220hello

不论正数还是负数，在计算机中都是以”补码“形式存储的。正数：原码、反码、补码三码合一。负数：原码为对应的正数符号位取反，反码为原码除符号位取反，补码为反码加一。

3.运算符

取余运算”%“，结果符号取决于被除数的符号：

public static void main(String[] args) { 
        int i1 = 12 % 5;
        int i2 = -12 % 5;
        int i3 = 12 % (-5);
        int i4 = (-12) % (-5);
        System.out.println("12%5\t"+i1);
        System.out.println("-12%5\t"+i2);
        System.out.println("12 % (-5)\t"+i3);
        System.out.println("(-12) % (-5)\t"+i4);
    } 

输出结果为：

12%5    2
-12%5   -2
12 % (-5)   2
(-12) % (-5)    -2

& 与 && 的区别：

• &：不管左端是true还是false，右端都会进行运算。&&：左端是false的话，右端不再计算。
• &还可以用作位运算符，当&操作符两边的表达式不是boolean类型时，&表示按位与操作（例如，我们通常使用0x0f来与一个整数进行&运算，来获取该整数的最低4个bit位）；&&操作符两端只能是boolean类型。

位运算符：直接对二进制进行操作。

使用位运算“^”进行数值交换：

int m = 3;
int n = 5;

m = m ^ n;
n = m ^ n;  //m ^ n ^ n == m
m = m ^ n;  //m ^ m ^ n == n

int i = 10;

String str1 = Integer.toBinaryString(i);//以二进制输出
String str2 = Integer.toHexString(i);//以十六进制输出

//使用位运算实现：将十进制整数以十六进制形式打印
int j = 36;
int m = j & 15;//15即1111
String s1 = (m <= 9) ? m + "" : (char)(m - 10 + 'A') + "";//注：<=中间不能加空格

int k = 36 >> 4;
int n = k & 15;
String s2 = (n <= 9) ? n + "" : (char)(n - 10 + 'A') + "";

System.out.println(s2 + s1);

从键盘输入数据：实现简单交互

import java.util.*;//Scanner类存在于util包中

public class Test{
    public static void main(String [] args){
        //创建一个Scanner对象
        Scanner s = new Scanner(System.in);

        System.out.println("请输入一个字符串：");
        //next():表示从键盘获取一个字符串
        String str = s.next();
        System.out.println(str);

        System.out.println("请输入一个数字：");
        int i = s.nextInt();
        System.out.println(i);

    }
}

switch-case控制结构：default是可选的，可以有也可以没有；default可放在任意位置上，不一定放在最后，即使放在前面也是最后判断（但是习惯上都会放到最后）；放到前面时需要加break，避免default执行后继续向下执行（所以最好都加break）。

4.流程控制

switch()中的变量类型： char, byte, short, int, 枚举, String（JDK1.7以上追加的）。

public static void main(String [] args){
        int i = 2;
        switch(i){
            default:
                System.out.println("other");
            case 1:
                System.out.println("one");
                break;
            case 2:
                System.out.println("two");
                break;

        }
        //输出two
    }

public static void main(String [] args){
        int i = 3;
        switch(i){
            default:
                System.out.println("other");
            case 1:
                System.out.println("one");
                break;
            case 2:
                System.out.println("two");
                break;

        }
        //输出other   one
    }

public static void main(String [] args){
        int i = 3;
        switch(i){
            default:
                System.out.println("other");
                break;
            case 1:
                System.out.println("one");
                break;
            case 2:
                System.out.println("two");
                break;

        }
        //输出other
    }

continue与break：
①continue跳出“当次”循环，break跳出“当前”循环。

public static void main(String [] args){
        for(int i = 0;i < 4;i++){
            for(int j = 0;j < 4;j++){
                if(j % 2 == 1){
                    break;
                }
                System.out.print(j);
            }
            System.out.println();
        }
}

输出：
0
0
0
0

public static void main(String [] args){
        for(int i = 0;i < 4;i++){
            for(int j = 0;j < 4;j++){
                if(j % 2 == 1){
                    continue;
                }
                System.out.print(j);
            }
            System.out.println();
        }
    }

输出：
02
02
02
02

②带标签的break与continue

public static void main(String [] args){
        label:for(int i = 0;i < 4;i++){
            for(int j = 0;j < 4;j++){
                if(j % 2 == 1){
                    continue label;
                }
                System.out.print(j);
            }
            System.out.println();
        }
}

输出：0000

public static void main(String [] args){
        label:for(int i = 0;i < 4;i++){
            for(int j = 0;j < 4;j++){
                if(j % 2 == 1){
                    break label;
                }
                System.out.print(j);
            }
            System.out.println();
        }
}

输出：0

5.数组

//静态初始化
int[] ages1 = new int[]{23,45,24};
int[] ages2 = {23,45,24};
int[] ages3 = new int[3]{23,45,24};//不能指定大小，报编译错误
int[] ages4;
ages4 = new int[]{23,45,24};

int[] ages5;
ages5 = {23,45,24};//错误写法！

//动态初始化
int[] heights = new int[3];
for(int i = 0;i < heights.length;i++){
    heights[i] = 170 + i * 10;
}

PS：数组有length属性，字符串有length()方法。

内存的基本结构：
①栈（Stack）：存放局部变量、对象的引用。
②堆（Heap）：存放new出来的东西。
③方法区：包名、类名、方法名、常量池。
④静态域：存放全局变量。

数组元素的默认初始化值：
①byte short int long : 0
②float double : 0.0
③char : 空格
④boolean : false
⑤引用类型变量 : null

---

面向对象

1.可变个数的形参

1. 格式：对于方法的形参：数据类型 … 形参名
2. 可变个数的形参的方法与同名的方法之间构成重载
3. 可变个数的形参在调用时，个数从0开始到无穷多个都可以
4. 使用可变多个形参的方法与方法的形参使用数组是一致的
5. 若方法中存在可变个数的形参，那么一定要声明在方法形参的最后
6. 在一个方法中，最多声明一个可变个数的形参

public class Test {
    public static void main(String[] args) {
        Test t = new Test();
        t.hello();
        t.hello("Erin");
        t.hello(new String[]{"China","Beijing"});
        t.hello(3, "China","Beijing");
    }

    //0个参数
    public void hello(){
        System.out.println("Hello World!");
    }

    //1个参数
    public void hello(String str){
        System.out.println("Hello " + str);
    }

    //参数为数组
//  public void hello(String[] strs){
//      for(int i = 0;i < strs.length;i++){
//          System.out.print(strs[i]  + "\t");
//      }
//      System.out.println("参数类型：数组");
//  }

    //可变参数
    public void hello(String ... strs){
        for(int i = 0;i < strs.length;i++){
            System.out.print(strs[i]  + "\t");
        }
        System.out.println("参数类型：可变参数");
    }

    public void hello(int j,String ... strs){
        System.out.print(j + "\t");
        for(int i = 0;i < strs.length;i++){
            System.out.print(strs[i]  + "\t");
        }
        System.out.println("参数类型：int,可变参数");
    }
}