Java学习入门

---

创建文件 HelloWorld.java(文件名需与类名一致)

public class HelloWorld {    public static void main(String[] args) {        System.out.println("Hello World");    }}

输出结果：Hello World
其中，
println() 是一个方法。
System 是系统类。
out 是标准输出对象。
System.out.println()这句话的用法是调用系统类 System 中的标准输出对象 out 中的方法 println()。

---

变量类型
局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

成员变量(实例变量)：成员变量是定义在类中，方法体、构造方法和语句块之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；

类变量(静态变量)：类变量也声明在类中，方法体之外，但必须声明为static类型。

---

源文件声明规则

• 一个源文件中只能有一个public类
• 一个源文件可以有多个非public类
• 源文件的名称应该和public类的类名保持一致。例如：源文件中public类的类名是Employee，那么源文件应该命名为Employee.java。
• 如果一个类定义在某个包中，那么package语句应该在源文件的首行。
• 如果源文件包含import语句，那么应该放在package语句和类定义之间。如果没有package语句，那么import语句应该在源文件中最前面。
• import语句和package语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。

package com.runoob.test;//它是按照路径 com/runoob/test/文件名.java 这样保存的import java.util.Date;import java.io.*;public class HelloWorld {}

---

对象和类

java因强制要求类名（唯一的public类）和文件名统一，因此在引用其它类时无需显式声明。在编译时，编译器会根据类名去寻找同名文件。
package 的作用就是 c++ 的 namespace 的作用，防止名字相同的类产生冲突。Java 编译器在编译时，直接根据 package 指定的信息直接将生成的 class 文件生成到对应目录下。如 package aaa.bbb.ccc 编译器就将该 .java 文件下的各个类生成到 ./aaa/bbb/ccc/ 这个目录。
import 是为了简化使用 package 之后的实例化的代码。假设 ./aaa/bbb/ccc/ 下的 A 类，假如没有 import，实例化A类为：new aaa.bbb.ccc.A()，使用 import aaa.bbb.ccc.A 后，就可以直接使用 new A() 了，也就是编译器匹配并扩展了 aaa.bbb.ccc. 这串字符串。

---

数据类型

分为内置数据类型和引用数据类型。
内置数据类型：byte,short,int,long,float,double,boolean(只能取true和false),char
可通过数据类型.SIZE得到该类型的二进制位数；
数据类型.MIN_VALUE得到该类型可以表示的最小的数；
数据类型.MAX_VALUE得到该类型可以表示的最大的数。

引用类型：引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。
例如Site site = new Site("Runoob")中的site变量即为引用变量。

• Java 里使用 long 类型的数据一定要在数值后面加上 L，否则将作为整型解析long value = 9223372036854775807L;

---

final关键字

• 当用final修饰一个类时，表明这个类不能被继承。

• 当用final修饰方法时，是把方法锁定，以防任何继承类修改它的含义。
  注：类的private方法会隐式地被指定为final方法。

• 当final修饰变量时，对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。
  
  上面的一段代码中，对变量i和obj的重新赋值都报错了。

• final和static
  static作用于成员变量用来表示只保存一份副本，而final的作用是用来保证变量不可变。

public class Test {    public static void main(String[] args)  {        MyClass myClass1 = new MyClass();        MyClass myClass2 = new MyClass();        System.out.println(myClass1.i);        System.out.println(myClass1.j);        System.out.println(myClass2.i);        System.out.println(myClass2.j);    }}class MyClass {    public final double i = Math.random();    public static double j = Math.random();}

上面的一段代码i是final变量，每次输出的两个i值都不相同；
j是static变量，每次输出的两个j值都是相同。
final详解

---

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

低  ------------------------------------>  高byte,short,char—> int —> long—> float —> double 

低级转换成高级是自动完成的，容量大的类型转换为容量小的类型时必须使用强制类型转换。如int i =128; byte b = (byte)i;

---

包(package)
为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。
作用：

1. 把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
2. 如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
3. 包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。
   例如,一个Something.java 文件它的内容

package net.java.utilpublic class Something{   ...}

那么它的路径应该是 net/java/util/Something.java 这样保存的。

---

访问控制

---

修饰符

• abstract 修饰符
  抽象类：
  抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。

abstract class Caravan{   private double price;   private String model;   private String year;   public abstract void goFast(); //抽象方法   public abstract void changeColor();}

抽象方法：
抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。

• synchronized 修饰符
  关键字声明的方法同一时间只能被一个线程访问。

public synchronized void showDetails(){.......}

• transient 修饰符

public transient int limit = 55;   // 不会持久化public int b; // 持久化

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

public class MyRunnable implements Runnable{    private volatile boolean active;    public void run()//运行在线程1    {        active = true;        while (active) // 第一行        {            // 代码        }    }    public void stop()//运行在线程2    {        active = false; // 第二行    }}

说明：如果是普通变量，即使线程2调用stop方法，改变了active的值，但是因为active为true时线程1使用了该值，所以while循环会继续运行；当active为volatile变量时，线程2调用stop方法，会结束线程1 的while循环。

---

运算符

• 位运算符
  
• 逻辑运算符
  
  短路逻辑运算符：当使用与逻辑运算符时，在两个操作数都为true时，结果才为true，但是当得到第一个操作为false时，其结果就必定是false，这时候就不会再判断第二个操作了。

public class LuoJi{    public static void main(String[] args){        int a = 5;//定义一个变量；        boolean b = (a<4)&&(a++<10);        System.out.println("使用短路逻辑运算符的结果为"+b);        System.out.println("a的结果为"+a);    }}

输出结果：

使用短路逻辑运算符的结果为falsea的结果为5

• 条件运算符（?:）
• instanceof 运算符
  该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。
  instanceof运算符使用格式如下：( Object reference variable ) instanceof (class/interface type)
  例如：String name = "James";
boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真

---

循环

• 增强 for 循环

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

声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
表达式：表达式是要访问的数组名，或者是返回值为数组的方法。
作用：类似于遍历数组。
例如：

public class Test {   public static void main(String args[]){      int [] numbers = {10, 20, 30, 40, 50};      for(int x : numbers ){         System.out.print( x );         System.out.print(",");      } }

输出结果：

10,20,30,40,50,

• break是跳出循环，continue是跳转到下一次循环的迭代。

---

数组

• 声明dataType[] arrayRefVar; // 首选的方法
• 创建arrayRefVar = new dataType[arraySize];
• 数组变量的声明和创建数组可以用一条语句完成：

dataType[] arrayRefVar = new dataType[arraySize];dataType[0]=value0;~dataType[arraySize-1]=valuek;

或

dataType[] arrayRefVar = {value0, value1, ..., valuek};

• arrayRefVar.length得到数组arrayRefVar的元素的个数。
  ## 多维数组的定义（二维为例） ##

type arrayName[][] = new typ[arraylenght1][arraylenght2];

其中，arraylenght1 为行数，arraylenght2 为列数。

---

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

• 给数组赋值：通过 fill 方法。

int[] arr = { 4, 1, 5, 8, 2, 9 };Arrays.fill(arr, 88);//用88来填充整个数组System.out.println(Arrays.toString(arr));//[88, 88, 88, 88, 88, 88]

• 对数组排序：通过 sort 方法,按升序。

Arrays.sort(arr);System.out.println(Arrays.toString(arr));// 输出 排序[1, 2, 4, 5, 8, 9]

• 比较数组：通过 equals 方法比较数组中元素值是否相等。
• 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)

int index = Arrays.binarySearch(arr, 7);//二分查找(折半查找)[1, 2, 4, 5, 8, 9]System.out.println("index=" + index);//如果没有找到，返回 插入点index=-5,负号说明没有找到// -5说明 要找的7本应该在 5-1=4的下标， 即现在8的位置

---

休眠(sleep)
sleep()使当前线程进入停滞状态（阻塞当前线程），让出CPU的使用、目的是不让当前线程独自霸占该进程所获的CPU资源，以留一定时间给其他线程执行的机会。单位ms。

 Thread.sleep(1000*3);   // 休眠3秒