Java初级笔记No.1（更新中）

2018.7.24

1、java中使用关键字final来定义常量；

2、java中的变量包括类变量，实例变量，局部变量三种类型，其中实例变量可以理解为C++中的类成员变量，局部变量很好理解(局部变量没有初始值)，为方法中的临时变量，重点理解类变量

类变量以static进行修饰，又叫静态变量：

public class Variable {
    static int allClicks=0; //类变量
    String str = "hello world"; //实例变量
    
    public void method() {
        int i = 0;  //局部变量
    }
}

java中的静态变量基本上与C++中的static变量一致，其具有以下性质：

3、java中的访问控制修饰符：
· default： 在同一个包内可见，不适用任何修饰符。
· private，public，protected，这三个修饰符的作用及意义与C++中基本一致，可以在编码中进行体会。

4、java中的非访问修饰符：
· static：与C++中相似，静态存储区，只有一个拷贝；
· final： 类比C++中的const，同时在类中可以定义final方法，这与C++中的const成员函数类似，理解为只读函数。
· abstract： 抽象，
抽象类不能用来实例化对象，声明抽象类的唯一目的就是为了将来对该类进行扩充。
如果一个类包含抽象方法，则该类一定要声明为抽象类。
抽象类可以包含抽象方法和非抽象方法。
抽象方法：没有任何实现的方法，该方法的具体实现由子类提供。
因此这个抽象的概念可以理解为C++中的纯虚函数类的作用。
· synchronized： 线程的同步；
· transient： 序列化的对象包含被transient修饰的实例变量时，JVM跳过该特定的变量。该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。？？？

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

5、java中的运算符：
· instanceof：该运算符用于操作对象实例，检查该对象是否是一个特定类型：

String name = "James";
boolean result = name instanceof String;  //返回true

6、java中的增强for循环（也叫做foreach循环），即为C++中的范围for语句，但java中还没有auto关键字。

7、java中使用\来进行转义：

public class testFile {
    public static void main(String[] args) {
        System.out.println("My name is \"James\"");
    }
}

8、java中的String对象一旦创建就不能修改了，这有别于C++中的string，java中如果需要对字符串进行更改，就需要使用StringBuffer & StringBuilder类。
关于String会写一篇专门的文章介绍。

9、 StringBuilder与StringBuffer之间最大的不同在于StringBuilder方法不是线程安全的。但StringBuilder相较于StringBuffer有速度优势，所以建议在不要求线程安全的情况下使用StringBuilder类：

public class testFile {
    public static void main(String[] args) {
        StringBuffer sBuffer = new StringBuffer("LiMing");
        sBuffer.append(" is");
        sBuffer.append(" a");
        sBuffer.append(" good boy");
        
        System.out.println(sBuffer);
    }
}

关于StringBuffer类会写一篇专门的文章介绍其常用方法。

10、java中使用的数组声明方法可以与C++类似，但是不建议使用这种方法：

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

dataType arrayRefVar[];    //效果相同，但不是首选方法

java中的数组可以作为函数的参数和返回值，就像STL中的vector一样。
另外java中还提供了Arrays类，这是为了分别的操作数组，Arrays类中包含了一系列对数组操作的方法。

11、java中提供了Date类来封装当前的日期和时间。
在使用Date类的时候需要导入import java.util.Date包才能调用类的方法：

import java.util.Date;

public class testFile {
    public static void main(String[] args) {
        Date date = new Date();
        
        System.out.println(date.toString());
    }
}  

另外，java中提供了SimpleDateFormat类来格式化日期，关于这部分会专门写一篇文章用于介绍其方法。

12、利用sleep方法使当前线程休眠：

import java.util.*;

public class testFile {
    public static void main(String[] args) {
        try {
            System.out.println(new Date() + "\n");
            Thread.sleep(1000*3);//休眠3秒
            System.out.println(new Date() + "\n");
        } catch (Exception e) {
            System.out.println("Got an exception");
        }
    }
}  

13、测量时间的方法：

import java.util.*;

public class testFile {
    public static void main(String[] args) {
        try {
            long start = System.currentTimeMillis();
            System.out.println(new Date() + "\n");
            Thread.sleep(5*60*10);
            long end = System.currentTimeMillis();
            System.out.println(new Date() + "\n");
            long diff = end - start;
            System.out.println("Difference is : " + diff);
        } catch (Exception e) {
            System.out.println("Got an exception");
        }
    }
}

14、Calendar类与GregorianCalendar类

15、Java中的正则表达式以及Matcher类

16、java中命令行参数的使用
有时候希望运行一个程序时再传递给它消息，这要考传递命令行参数给main()函数实现。
命令行参数是在执行时紧跟在程序名字后面的信息：

public class testFile {
    public static int Max(int num1, int num2) {
        return num1>num2?num1:num2;
    }
    
    public static void main(String[] args) {
        for (int i = 0; i < args.length; ++i) {
            System.out.println("args[" + i + "]:" + args[i]);
        }
    }
}

17、java中的构造函数与C++中的基本一致，对于一个类来说，会有一个默认构造函数，在我们自己定义了构造函数之后，默认构造函数失效。

18、可变参数：
java支持传递同类型的可变参数给一个方法，在方法声明中，在指定参数类型后加一个省略号...，值的注意的是，一个方法中只能指定一个可变参数，它必须是方法的最后一个参数：

public class testFile {
    public static void main(String args[]) {
        //调用可变参数的方法
        printMax(2,3,5,3,6);
        printMax(new double[]{1,2,3});
    }
        
    public static void printMax(double ... numbers) {
            if (numbers.length == 0) {
                System.out.println("No argument passed");
                return;
            }
            
            double result = numbers[0];
            
            for (int i = 1; i < numbers.length; ++i) {
                if (numbers[i] > result)
                    result = numbers[i];
            }
            System.out.println("The max value is : " + result);
        }
}

19、finalize()方法：
java中允许定义这样的方法，它在对象被垃圾收集器析构之前调用，这个方法叫做finalize()，用来清除回收对象。这里可以联想C++中的析构函数。这里主要可以帮助我们完成一些想在对象销毁之前的操作。

我们知道java中内存回收可以由JVM来自动完成，这里的finalize()方法就是一种手动内存回收的方法。

public class FinalizationDemo {
    public static void main(String[] args) {
        Cake c1 = new Cake(1);
        Cake c2 = new Cake(2);
        Cake c3 = new Cake(3);
        
        c2 = c3 = null;
        System.gc();  //调用java的垃圾收集器
    }
}

class Cake extends Object {
    private int id;
    public Cake(int id) {
        this.id = id;
        System.out.println("Cake Object " + id + " is created");
    }
    
    protected void finalize() throws java.lang.Throwable {
        super.finalize();
        System.out.println("Cake Object " + id + " is disposed");
    }
}