Java Notes

Terminal 中运行

public class HelloWorld {
    /* 第一个Java程序
     * 它将打印字符串 Hello World
     */
    public static void main(String []args) {
        System.out.println("Hello World"); // 打印 Hello World
    }
}

• javac HelloWorld.java compile
• java HelloWorld run
• 所有的 Java 程序由 public static void main(String []args)

变量

内置数据类型

// int 
// SIZE and MAX_VALUE is the property of Integer Object 
Integer.SIZE; // 32
Integer.MAX_VALUE; 2^31-1 

常量

final float PI = 3.14;

引用类型

• 对象、数组都是引用数据类型。
• 所有引用类型的默认值都是null。

Java修饰符

像其他语言一样，Java可以使用修饰符来修饰类中方法和属性。主要有两类修饰符：

访问控制修饰符

• private ：类内部
• default：同一包
• protected： 同一包，以及所有子类（子类不一定是同一包）
• public：所有类可见

访问控制和继承

请注意以下方法继承的规则：

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

非访问控制修饰符

• static: 静态变量类的变量里说过了，静态方法：独立于对象；静态方法不能使用类的非静态变量。静态方法从参数列表(String args[])得到数据，然后计算这些数据。
• final: final变量不能被修改；final方法可以被继承，不能被修改
• abstract：abstract类不能实例化对象，abstract方法就是一个空的方法，需要子类来提供
• synchronized：声明的方法同一时间只能被一个线程访问
• 还有transient and volatile

运算符

位运算不是很熟，其他的略了

• & and
• | or
• ^ 异或(不同才为1)
• ~ 取反
• << , >>左移和右移

类和对象 （重点）

类中的变量类型（区别）

表观区别

• 方法中（包括constructor）：局部变量
• 方法外：成员变量（new一次实例化一次），类变量（必须有static）

其他区别

• 局部变量：方法执行时候创建，完事了销毁； 没有默认值， 必须初始化； 栈上分配
• 实例变量（成员变量）： 实例化对象的时候确定实例变量；有默认值；
• 类变量（静态变量）： 无论一个类创建了多少个对象，类只拥有类变量的一份拷贝；静态变量在第一次被访问时创建，在程序结束时销毁；有默认值

封装 多态 继承 重载

几种常用的类

Number & Math 类

在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情形。为了解决这个问题，Java 语言为每一个内置数据类型提供了对应的包装类。
所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类。这种由编译器特别支持的包装称为装箱，所以当内置数据类型被当作对象使用的时候，编译器会把内置类型装箱为包装类。相似的，编译器也可以把一个对象拆箱为内置类型。Number 类属于 java.lang 包。

Java 1.5之后可以自动装箱 > https://droidyue.com/blog/2015/04/07/autoboxing-and-autounboxing-in-java/

• 自动装箱时编译器调用valueOf()将原始类型值转换成对象，同时自动拆箱时，编译器通过调用类似intValue(),doubleValue()这类的方法将对象转换成原始类型值。
• 自动装箱是将boolean值转换成Boolean对象，byte值转换成Byte对象，char转换成Character对象，float值转换成Float对象，int转换成Integer，long转换成Long，short转换成Short，自动拆箱则是相反的操作。

Math类

• Math.sin()// 等各种三角函数;
• 可以用在Number类型转换的（重要）：
  • x.longValue(); // 以 long 形式返回指定的数值
  • x.toString();
  • Integer x =Integer.valueOf(9); //valueOf() 方法用于返回给定参数的原生 Number 对象值，参数可以是原生数据类型, String等。
  • x.equals(y); // 参数类型与数值都相等返回 True
• Math.max(); Math.pow(x, n)/exp(); Math.ceil()/floor()/rint()/round();

Character 类

• char的包装类是Character
• 常用方法：isLetter()/isDigit()/isWhiteSpace()/isUpperCase/toUpperCase()

String and StringBuffer/StringBuilder

• String 有一大堆构造方法：字符串，char数组，…
• 常用方法：String str = "hello";
  • str.length(); //很傻逼的是数组用length，List用size()
  • str1.concat(str2); // 就不能直接加起来吗，非要搞个StringBuilder才能改变字符串
  • str.charAt(index); // 超级无语
  • str.subString(begin index, end index); // C++貌似是begin index和length
  • 其他的用到了再说

StringBuilder and StringBuffer

• StringBuilder 速度快，但是不是线程安全的（不能同步访问）//为啥；要求线程安全时必须用StringBuffer
• 常用方法：StringBuffer sb = new StringBuffer("hello");
  • sb.append("a");
  • sb. delete(int start, int end)
  • sb.insert(int offset, int i)
  • sb.replace(int start, int end, String str)
  • length(), charAt(), subString()是一样的

一些数据结构

Array

• Java 语言中提供的数组是用来存储固定大小的同类型元素。
• 可以用a[i] 来访问了
• Arrays类，便捷操纵数组
  • Arrays.sort(a);
  • Arrays.equals(a1, a2)
  • Arrays.fill(a, 0);

import java.util.*;

int[] nums = new int[5]; // array size
int[] nums2 = {1,2,3,4};
int[] nums3 = new int[]{1,2,3,4};
System.out.println(Arrays.toString(nums2));
// or use for loop to print

Java Stream, I/O

• java.io包
• 一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向一个目标写数据。
• Java 为 I/O 提供了强大的而灵活的支持，使其更广泛地应用到文件传输和网络编程中。

Read from console

• 把System.in包裹在BufferedReader对象中创建字符流 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
• 用reader() 方法包裹BufferedReader，字符串用readLine()，int read( ) throws IOException

// 说实话和cin cout比起来有一丢丢的麻烦

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.println("please input");
// 1. read a character
char c;
c = (char) br.read(); // 这里还要转换
System.out.println("c: " + c);
// 2. read a string
String str;
str = br.readLine();
System.out.println("str: " + str);

Write to console

System.out.write(); // similar to println()
what is the difference??

File

• FileInputStream
• FileOutputStream

// 输入
// 或 InputStream f = new FileInputStream("C:/java/hello");
File f = new File("C:/java/hello");
InputStream out = new FileInputStream(f);

// 输出
// 或 OutputStream f = new FileOutputStream("C:/java/hello")
File f = new File("C:/java/hello");
OutputStream f = new FileOutputStream(f);

菜鸟上的例子，还蛮好的

//文件名 :fileStreamTest2.java
import java.io.*;
 
public class fileStreamTest2 {
    public static void main(String[] args) throws IOException {
 
        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对象中
            // 有点像 while(intput >> line)
        }
        System.out.println(sb.toString());
        reader.close();
        // 关闭读取流
 
        fip.close();
        // 关闭输入流,释放系统资源
    }
}

异常处理

异常是程序中的一些错误，但并不是所有的错误都是异常
Java 程序通常不捕获错误。错误一般发生在严重故障时

• 检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
• 运行时异常： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
• 错误： 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。
  

捕获异常

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

} finally {
	// 无论是否发生异常，finally 代码块中的代码总会被执行。
	// 在 finally 代码块中，可以运行清理类型等收尾善后性质的语句。
}

throws

方法用throws关键字来声名
IO中就用到了

import java.io.*;
public class className
{
  public void deposit(double amount) throws RemoteException
  {
    // Method implementation
    throw new RemoteException();
  }
  //Remainder of class definition
}

Collections

Collecions
List/ ArrayList
Map/HashMap/HashTable
Set/HashSet
Queue/ Stack
LinkedList