Java粗整理-1

本文基于菜鸟教程-java

Java分为三个体系：

• JavaSE（J2SE）（Java2 Platform Standard Edition，java平台标准版）
• JavaEE  (J2EE)     (Java 2 Platform,Enterprise Edition，java平台企业版)
• JavaME  (J2ME)    (Java 2 Platform Micro Edition，java平台微型版)。
• 2011年7月28日，甲骨文发布java7.0的正式版。
• 2014年3月18日，Oracle公司发表Java SE 8。

运行 Java 程序需要安装 JRE

开发 Java 程序需要安装 JDK。

Java语言是体系结构中立的：

Java程序（后缀为java的文件）在Java平台上被编译为体系结构中立的字节码格式（后缀为class的文件），然后可以在实现这个Java平台的任何系统中运行。这种途径适合于异构的网络环境和软件的分发。在运行时，Java平台中的Java解释器对这些字节码进行解释执行，执行过程中需要的类在联接阶段被载入到运行环境中。Java编译器是用Java实现的，Java的运行环境是用ANSI C实现的。

Java语言是多线程的：

在Java语言中，线程是一种特殊的对象，它必须由Thread类或其子（孙）类来创建。通常有两种方法来创建线程：其一，使用型构为Thread(Runnable)的构造子将一个实现了Runnable接口的对象包装成一个线程，其二，从Thread类派生出子类并重写run方法，使用该子类创建的对象即为线程。值得注意的是Thread类已经实现了Runnable接口，因此，任何一个线程均有它的run方法，而run方法中包含了线程所要运行的代码。

命名方式

• 类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。
• 方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。myMethod
• 源文件名：源文件名必须和类名相同，MyFirstJavaClass.java 

源文件声明规则

• 一个源文件中只能有一个public类
• 源文件的名称应该和public类的类名保持一致。
• 如果一个类定义在某个包中，那么package语句应该在源文件的首行。
• 如果源文件包含import语句，那么应该放在package语句和类定义之间。

创建对象需要以下三步：

• 声明：声明一个对象，包括对象名称和对象类型。
• 实例化：使用关键字new来创建一个对象。
• 初始化：使用new创建对象时，会调用构造方法初始化对象。

Java包

包主要用来对类和接口进行分类。当开发Java程序时，可能编写成百上千的类，因此很有必要对类和接口进行分类。

载入java_installation/java/io路径下的所有类：import java.io.*;

创建对象

需要以下三步：

• 声明：声明一个对象，包括对象名称和对象类型。
• 实例化：使用关键字new来创建一个对象。
• 初始化：使用new创建对象时，会调用构造方法初始化对象。

数据类型

byte 是8位、有符号的，以二进制补码表示的整数

char是一个单一的 16 位 Unicode 字符；最小值是 \u0000（即为0）；最大值是 \uffff（即为65,535）；

在定义 float 类型时必须在数字后面跟上 F 或者 f。

final 关键字来修饰常量，声明方式和变量类似：final double PI = 3.1415927;

• 静态变量可以通过：ClassName.VariableName（类名.变量名）的方式访问。
• 静态变量在第一次被访问时创建，在程序结束时销毁。
• 局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

引用类型

• 引用类型指向一个对象，指向对象的变量是引用变量。变量一旦声明后，类型就不能被改变了。
• 对象、数组都是引用数据类型。
• 所有引用类型的默认值都是null。

自动类型转换

运算中，不同类型的数据先转化为同一类型，然后进行运算

低  ------------------------------------>  高

byte,short,char—> int —> long—> float —> double

访问控制修饰符

• default (缺省）: 在同一包内可见
• private : 在同一类内可见，注意：不能修饰类（外部类）
• public : 对所有类可见，使用对象：类、接口、变量、方法
• protected : 对同一包内的类和所有子类可见，注意：不能修饰类（外部类）。

接口及接口的成员变量和成员方法不能声明为 protected

接口里的变量都隐式声明为 public static final,而接口里的方法默认情况下访问权限为 public。

访问的继承

• 父类中声明为 public 的方法在子类中也必须为 public。
• 父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
• 父类中声明为 private 的方法，不能够被继承。

非访问修饰符

static 修饰符

 静态变量：

static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。

静态方法：

static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。

final 修饰符

final 修饰的类不能够被继承，修饰的方法能被继承但不能重新定义，修饰的变量为常量不可修改。

abstract 修饰符

           抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。抽象类可以包含抽象方法和非抽象方法。一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类。任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。

synchronized

synchronized 声明的方法同一时间只能被一个线程访问。

volatile

volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

运算符

instanceof 运算符

该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）

String name = "James";

boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真

 

Java 增强 for 循环

String [] names ={"James", "Larry", "Tom", "Lacy"};
      for( String name : names ) {
         System.out.print( name );
         System.out.print(",");
      }

包装类

一般地，当需要使用数字的时候，我们通常使用内置数据类型，如：byte、int、long、double 等。在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情形。为了解决这个问题，Java 语言为每一个内置数据类型提供了对应的包装类。所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类。为内置数据类型char提供了包装类Character类。

Java Math 类

Math.sin(Math.PI/2)

Java Character 类

Character.isLetter('c');

Java String 类

注意:String 类是不可改变的，所以你一旦创建了 String 对象，那它的值就无法改变

当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。

Java 数组

dataType[] arrayRefVar;   // 首选的方法

创建数组
dataType[] arrayRefVar = new dataType[arraySize];

Arrays 类

java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。

Java 日期时间

java.util 包提供了 Date 类来封装当前的日期和时间。

        // 初始化 Date 对象
       Date date = new Date();
        
       // 使用 toString() 函数显示日期时间
       System.out.println(date.toString());

       System.out.println(new Date( ) + "\n"); 
       Thread.sleep(1000*3);   // 休眠3秒
       System.out.println(new Date( ) + "\n");

正则表达式

 \s+ 可以匹配多个空格

^ 定义了以什么开始

\d+ 匹配一个或多个数字

? 设置括号内的选项是可选的

\. 匹配 "."

在 Java 的正则表达式中，两个 \\ 代表其他语言中的一个 \

Java 方法

方法的命名规则

• 1.方法的名字的第一个单词应以小写字母作为开头，后面的单词则用大写字母开头写，不使用连接符。例如：addPerson。
• 2.下划线可能出现在 JUnit 测试方法名称中用以分隔名称的逻辑组件。一个典型的模式是：test_，例如 testPop_emptyStack

重载的方法必须拥有不同的参数列表。你不能仅仅依据修饰符或者返回类型的不同来重载方法。

可变参数

typeName... parameterName

public static void printMax( double... numbers) {
        if (numbers.length == 0) {
            System.out.println("No argument passed");
            return;
        }

inalize() 方法

Java 允许定义这样的方法，它在对象被垃圾收集器析构(回收)之前调用，这个方法叫做 finalize( )，它用来清除回收对象。当然，Java 的内存回收可以由 JVM 来自动完成。如果你手动使用，则可以使用上面的方法。

Java 流(Stream)、文件(File)和IO

一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向一个目标写数据。

控制台读写

为了获得一个绑定到控制台的字符流，你可以把 System.in 包装在一个 BufferedReader 对象中来创建一个字符流。

在此前已经介绍过，控制台的输出由 print( ) 和 println() 完成。这些方法都由类 PrintStream 定义，System.out 是该类对象的一个引用。PrintStream 继承了 OutputStream类，并且实现了方法 write()。这样，write() 也可以用来往控制台写操作。

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("输入字符, 按下 'q' 键退出。");
        // 读取字符
        do {
            c = (char) br.read();
            System.out.println(c);
        } while (c != 'q');

//向控制台输出
        int b;
        b = 'A';
        System.out.write(b);
        System.out.write('\n');

文件读写

程序中的输入输出都是以流的形式保存的，流中保存的实际上全都是字节文件。在字节流中输出数据主要是使用OutputStream完成，输入使的是InputStream主要用来处理字节或二进制对象，在字符流中输出主要是使用Writer类完成，输入流主要使用Reader类完成，主要用来处理字符或字符串，处理的单元为2个字节的Unicode字符。（这四个都是抽象类）

字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的，所以它对多国语言支持性比较好！如果是音频文件、图片、歌曲，就用字节流。字节流可用于任何类型的对象，包括二进制对象，而字符流只能处理字符或者字符串； 2. 字节流提供了处理任何类型的IO操作的功能，但它不能直接处理Unicode字符，而字符流就可以。

import java.io.*;
 
public class fileStreamTest {
    public static void main(String args[]) {
        try {
            byte bWrite[] = { 11, 21, 3, 40, 5 };
            OutputStream os = new FileOutputStream("test.txt");
            for (int x = 0; x < bWrite.length; x++) {
                os.write(bWrite[x]); // writes the bytes
            }
            os.close();
 
            InputStream is = new FileInputStream("test.txt");
            int size = is.available();
 
            for (int i = 0; i < size; i++) {
                System.out.print((char) is.read() + "  ");
            }
            is.close();
        } catch (IOException e) {
            System.out.print("Exception");
        }
    }
}

        File f = new File("a.txt");
        FileOutputStream fop = new FileOutputStream(f);
        // 构建FileOutputStream对象,文件不存在会自动新建
 
        OutputStreamWriter writer = new OutputStreamWriter(fop, "UTF-8");
        // 构建OutputStreamWriter对象,参数可以指定编码,默认为操作系统默认编码,windows上是gbk
 
        writer.append("中文输入");
        // 写入到缓冲区
        writer.append("\r\n");
        writer.append("English");
        // 刷新缓存冲,写入到文件,如果下面已经没有写入的内容了,直接close也会写入
         writer.close();
        // 关闭写入流,同时会把缓冲区内容写入文件,所以上面的注释掉
         fop.close();
        // 关闭输出流,释放系统资源
 
        FileInputStream fip = new FileInputStream(f);
        // 构建FileInputStream对象
 
        InputStreamReader reader = new InputStreamReader(fip, "UTF-8");
        // 构建InputStreamReader对象,编码与写入相同
 
        StringBuffer sb = new StringBuffer();
        while (reader.ready()) {
            sb.append((char) reader.read());
            // 转成char加到StringBuffer对象中
        }
        System.out.println(sb.toString());
        reader.close();
        // 关闭读取流
 
        fip.close();
        // 关闭输入流,释放系统资源
 

Java Scanner 类

java.util.Scanner 是 Java5 的新特征，我们可以通过 Scanner 类来获取用户的输入。

下面是创建 Scanner 对象的基本语法：

Scanner s = new Scanner(System.in);

Java 异常处理

Exception 类是 Throwable 类的子类。除了Exception类外，Throwable还有一个子类Error 。

Java 程序通常不捕获错误。错误一般发生在严重故障时，它们在Java程序处理的范畴之外。

Error 用来指示运行时环境发生的错误。

例如，JVM 内存溢出。一般地，程序不会从错误中恢复。

异常类有两个主要的子类：IOException 类和 RuntimeException 类。

捕获异常

try
{
   // 程序代码
}catch(ExceptionName e1)
{
   //Catch 块
}