Java基础（精简复习）

第一部分

一. 开发环境配置

1. 下载安装JDK
2. 配置环境变量：我的电脑——属性——高级系统设置——高级——环境变量——系统变量
   ——变量名：JAVA_HOME
   变量值：C:\Program Files (x86)\Java\jdk1.8.0_91
   ——变量名：CLASSPATH
   变量值：.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;
   ——变量名：Path
   变量值：%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;
3. 测试JDK：开始——运行——cmd——键入java -version、java、javac
4. 下载安装Eclipse

二. 基本语法

1. 大小写敏感
2. 类名首字母大写，每个单词首字母大写；方法名首字母小写，后面单词首字母大写
3. 类名、变量名以及方法名都被称为标识符；标识符应以大小写字母、 $ 或者 _ 开始；关键字不能用作标识符
4. 修饰符：使用修饰符来修饰类中方法和属性；
   访问控制修饰符 : default, public , protected, private
   非访问控制修饰符 : final, abstract, static, synchronized
5. 变量分为局部变量、类变量（静态变量）、成员变量（非静态变量）
6. 枚举：枚举限制变量只能是预先设定好的值。枚举可以单独声明或者声明在类里面。方法、变量、构造函数也可以在枚举中定义。

class FreshJuice {
   enum FreshJuiceSize{ SMALL, MEDIUM , LARGE }
   FreshJuiceSize size;
}
 
public class FreshJuiceTest {
   public static void main(String []args){
      FreshJuice juice = new FreshJuice();
      juice.size = FreshJuice.FreshJuiceSize.MEDIUM  ;
   }
}

7. ： 关键字、保留字
8. 注释：

public class Test {
   /* 这是一个Java程序
    *它将打印Notes Test
    * 这是一个多行注释的示例
    */
    public static void main(String []args){
       // 这是单行注释的示例
       /* 这个也是单行注释的示例 */
       System.out.println("Notes Test"); 
    }
}

三. 对象和类

public class Pig{
   int pigAge;
   public Pig(String name){
      // 这个构造器仅有一个String类型参数：name
      System.out.println("小猪的名字是 : " + name ); 
   }
 
   public void setAge( int age ){
       pigAge = age;
   }
 
   public int getAge( ){
       System.out.println("小猪的年龄为 : " + pigAge ); 
       return pigAge;
   }
 
   public static void main(String[] args){
      /* 创建对象 */
      Pig myPig = new Pig( "tommy" );
      /* 通过方法来设定age */
      myPig.setAge( 2 );
      /* 调用另一个方法获取age */
      myPig.getAge( );
      /*你也可以像下面这样访问成员变量 */
      System.out.println("变量值 : " + myPig.pigAge ); 
   }
}

1. 一个源文件中只能有一个public类，可以有多个非public类
2. 类的类型有抽象类、final类、内部类、匿名类。
3. Import语句：import java.io.*;

四. 基本数据类型

1. 八种基本类型
   byte a = 100
   short b = 1000
   int c = 100000
   long d = 1000000L
   float e = 234.5f
   double f = 123.4
   boolean g = true
   char h = ‘A’
2. 引用类型：
   引用类型指向一个对象，指向对象的变量是引用变量。
   对象、数组都是引用数据类型，默认值都是null。
3. 常量：
   常量在程序运行时是不能被修改的。
   使用 final 关键字来修饰常量：
   final double PI = 3.1415927;
4. Java语言支持一些特殊的转义字符序列：
   "two\nlines"
String a = "\u0001";

符号	字符含义
\n	换行
\r	回车
\f	换页符
\b	退格
\0	空字符
\s	字符串
\t	制表符
"	双引号
’	单引号
\	反斜杠
\ddd	八进制字符（ddd）
\uxxxx	16进制Unicode字符（xxxx）

5. 自动类型转换

char c1='a';//定义一个char类型
int i1 = c1;//char自动类型转换为int

不能对boolean类型进行类型转换。
转换前的数据类型的位数要低于转换后的数据类型。

6. 强制类型转换

int i1 = 123;
byte b = (byte)i1;//强制类型转换为byte

转换的数据类型必须是兼容的。
转换过程中可能导致溢出或损失精度。

7. 变量类型

类变量（静态变量）

独立于方法之外的变量，用 static 修饰。

静态变量在第一次被访问时创建，在程序结束时销毁。

静态变量可以通过：ClassName.VariableName的方式访问。

实例变量

独立于方法之外的变量，不过没有 static 修饰。

实例变量在对象创建的时候创建，在对象被销毁的时候销毁。

局部变量

类的方法中的变量。

局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁。

五. 修饰符

1.访问控制修饰符：
使用访问控制符来保护对类、变量、方法和构造方法的访问

修饰符	当前类	同一包内	子孙类（同一包）	子孙类（不同包）	其他包
public	Y	Y	Y	Y	Y
protected	Y	Y	Y	Y/N	N
default	Y	Y	Y	N	N
private	Y	N	N	N	N

2. 非访问修饰符：
   static 修饰符，用来修饰类方法和类变量。
   final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
   abstract 修饰符，用来创建抽象类和抽象方法。
   synchronized 和 volatile 修饰符，主要用于线程的编程。

六. 运算符

类型	操作符	描述
算术运算符	+	加法 - 相加运算符两侧的值
–	-	减法 - 左操作数减去右操作数
–	*	乘法 - 相乘操作符两侧的值
–	/	除法 - 左操作数除以右操作数
–	%	取余 - 左操作数除以右操作数的余数
–	++	自增: 操作数的值增加1
–	- -	自减: 操作数的值减少1
关系运算符	==	检查如果两个操作数的值是否相等，如果相等则条件为真
–	!=	检查如果两个操作数的值是否相等，如果值不相等则条件为真
–	>	检查左操作数的值是否大于右操作数的值，如果是那么条件为真
–	<	检查左操作数的值是否小于右操作数的值，如果是那么条件为真
–	>=	检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真
–	<=	检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真
位运算符	&	如果相对应位都是1，则结果为1，否则为0
–	丨	如果相对应位都是0，则结果为0，否则为1
–	^	如果相对应位值相同，则结果为0，否则为1
–	~	按位取反运算符翻转操作数的每一位，即0变成1，1变成0
–	<<	按位左移运算符。左操作数按位左移右操作数指定的位数
–	>>	按位右移运算符。左操作数按位右移右操作数指定的位数
–	>>>	按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充
逻辑运算符	&&	称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真
–	丨丨	称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真
–	!	称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false
赋值运算符	=	简单的赋值运算符，将右操作数的值赋给左侧操作数
–	+=	加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数
–	-=	减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数
–	*=	乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数
–	/=	除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数
–	%=	取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数
–	<<=	左移位赋值运算符
–	>>=	右移位赋值运算符
–	&=	按位与赋值运算符
–	^=	按位异或赋值操作符
–	丨=	按位或赋值操作符
条件运算符	( ? : )	被称为三元运算符，variable x = (expression) ? value if true : value if false
instanceof 运算符	instanceof	用于操作对象实例，检查该对象是否是一个特定类型，( Object reference variable ) instanceof (class/interface type)

第二部分

七. 循环结构

1. while循环：

while( 布尔表达式 ) {
  //循环内容
}

2. do…while 循环：

do {
       //代码语句
}while(布尔表达式);

3. for循环：

for(初始化; 布尔表达式; 更新) {
    //代码语句
}

4. 增强 for 循环：

for(声明语句 : 表达式)
{
   //代码句子
}

5. break关键字主要用在循环语句或者 switch 语句中，用来跳出整个语句块。
6. continue 关键字适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。

八. 条件语句

if…else语句

if(布尔表达式 1){
   //如果布尔表达式 1的值为true执行代码
   if(布尔表达式 4){
      //嵌套if
      //如果布尔表达式 4的值为true执行代码
   }
}else if(布尔表达式 2){
   //如果布尔表达式 2的值为true执行代码
}else if(布尔表达式 3){
   //如果布尔表达式 3的值为true执行代码
}else {
   //如果以上布尔表达式都不为true执行代码
}

九. switch case

switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。

switch(expression){
    case value :
       //语句
       break; //可选
    case value :
       //语句
       break; //可选
    //你可以有任意数量的case语句
    default : //可选
       //语句
}

十. String、StringBuffer 和 StringBuilder 类

1. String 类是不可改变的，所以你一旦创建了 String 对象，那它的值就无法改变了。如果需要对字符串做很多修改，那么应该选择使用 StringBuffer & StringBuilder 类。
2. StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。
   由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。

public class Test{
  public static void main(String args[]){
    StringBuffer sBuffer = new StringBuffer("菜鸟教程官网：");
    sBuffer.append("www");
    sBuffer.append(".runoob");
    sBuffer.append(".com");
    System.out.println(sBuffer);  
  }
}

十一. 数组

Java 语言中提供的数组是用来存储固定大小的同类型元素。

public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};
 
      // 打印所有数组元素
      for (int i = 0; i < myList.length; i++) {
         System.out.println(myList[i] + " ");
      }
      // 查找最大元素
      double max = myList[0];
      for (int i = 1; i < myList.length; i++) {
         if (myList[i] > max) max = myList[i];
      }
      System.out.println("Max is " + max);
   }
}

十二. 日期时间

1. java.util 包提供了 Date 类来封装当前的日期和时间。
2. 使用 SimpleDateFormat 格式化日期。

import  java.util.*;
import java.text.*;
 
public class DateDemo {
   public static void main(String args[]) {
 
      Date dNow = new Date( );
      SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd hh:mm:ss");
 
      System.out.println("当前时间为: " + ft.format(dNow));
   }
}

第三部分

十三. 正则表达式

1. 正则表达式定义了字符串的模式。
2. 正则表达式可以用来搜索、编辑或处理文本。

以下实例中使用了正则表达式 . *runoob. * 用于查找字符串中是否包了 runoob 子串：

import java.util.regex.*;
 
class RegexExample1{
   public static void main(String args[]){
      String content = "I am noob " +
        "from runoob.com.";
 
      String pattern = ".*runoob.*";
 
      boolean isMatch = Pattern.matches(pattern, content);
      System.out.println("字符串中是否包含了 'runoob' 子字符串? " + isMatch);
   }
}

十四. 流(Stream)、文件(File)和IO

1. 一个流可以理解为一个数据的序列。
2. Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。
   

//使用 BufferedReader 在控制台读取字符
 
import java.io.*;
 
public class BRRead {
    public static void main(String args[]) throws IOException {
        char c;
        // 使用 System.in 创建 BufferedReader
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("输入字符, 按下 'q' 键退出。");
        // 读取字符
        do {
            c = (char) br.read();
            System.out.println(c);
        } while (c != 'q');
    }
}

详情参考菜鸟教程：Java 流(Stream)、文件(File)和IO

十五. Scanner类

我们可以通过 Scanner 类来获取用户的输入。

import java.util.Scanner;
 
public class ScannerDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        // 从键盘接收数据
 
        // nextLine方式接收字符串
        System.out.println("nextLine方式接收：");
        // 判断是否还有输入
        if (scan.hasNextLine()) {
            String str2 = scan.nextLine();
            System.out.println("输入的数据为：" + str2);
        }
        scan.close();
    }
}

1. next() 不能得到带有空格的字符串。
2. nextLine()方法返回的是输入回车之前的所有字符，可以获得空白。

十六. 异常处理

异常发生的原因有很多，通常包含以下几大类:

用户输入了非法数据。

要打开的文件不存在。

网络通信时连接中断，或者JVM内存溢出。

import java.io.*;
public class ExcepTest{
 
   public static void main(String args[]){
      try{
         int a[] = new int[2];
         System.out.println("Access element three :" + a[3]);
      }catch(ArrayIndexOutOfBoundsException e){
         System.out.println("Exception thrown  :" + e);
      }
      System.out.println("Out of the block");
   }
}

1. throws/throw 关键字：如果一个方法没有捕获到一个检查性异常，那么该方法必须使用 throws 关键字来声明。throws 关键字放在方法签名的尾部。也可以使用 throw 关键字抛出一个异常。
2. finally关键字：用来创建在 try 代码块后面执行的代码块。无论是否发生异常，finally 代码块中的代码总会被执行。