Java 语言基础笔记（一）

Java 常用基础（一）

原文写于 2017-12-02

输入输出

//输入
Scanner in = new Scanner(new BufferedInputStream(System.in));
in.hasNext();
in.nextInt();
//输出
PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
out.println("Hello World");
out.flush();

随机数

Random rand =  new Random(47)

47 为随机数种子，随机数种子一样产生的随机数序列一样，若空则以当前时间为种子，每次产生的随机数不一样
产生[0,1)区间的小数 Math.random();

进制

十六进制以 0x 开头

char c = 0xffff;     // max char hex value
byte b = 0x7f;       // max byte hex value
short s = 0x7fff;    // max short hex value

如果试图将一个变量初始化为超出自身表示范围的值（无论这个值的数值形式如何），编译器都会向我们报告一条错误信息。如果超出范围，编译器会将值自动转换为 int 型，并告诉我们需要对这次赋值进行“窄化转型”

窄化转型

将能容纳更多信息的数据类型转换成无法容纳那么多信息的类型，有可能面临信息丢失的危险

//如浮点型转换为整形
int i = 29.7;
print(i);
//输出29，而不是30
round()
java.lang 中的四舍五入函数

double d = 29.7;
print(Math.round(d));
//将输出30
指数记数法
// 1.3e-43表示的是1.3 x 10`-43f
float f = 1.3e-43f
//编译器通常会将指数作为双精度（double）处理，在尾部加上f是告诉编译器将double 转换成float，否则会出错

按位操作符

| 操作符 | 注释 |
| :————————: | :——–: | ———- |
| & | 与 |
| | | 或 |
| ~ | 非 |
| &=、 | =、^= | 都是合法的 |
| <<、 >>、 <<=、 >>=、 >>>= | 移位操作符 |

类型转换

只要类型比 int 小，（即 char byte short），在运算之前这些值会自动转换成 int。这也一来，最终生成的结果就是 int 型。如果把结果值赋值给较小的类型，就必须使用强制类型转换（既然把结果赋值给了较小的类型，就可能出现信息的丢失）。
通常，表达式中出现的最大的数据类型决定了表达式最终结果的数据类型，如果将一个 float 值与一个 double 值相乘，结果就是 double；如果将一个 int 和一个 long 值相加，则结果为 long。

“==” 与 equals()

“==”比较基本数据类型，相同返回 true 不用返回 false
比较引用时，如果引用指向内存中的同一对象则返回 true。

equals()

public  boolean equals(Object obj)

当参数 obj 引用的对象与当前对象为同一个对象时，就返回 true,否则返回 false。
equals()方法的本意为确定两个对象的引用是否相同，而 JDK 类中有一些类覆盖了 oject 类的 equals()方法，比较规则为：如果两个对象的类型一致，并且内容一致，则返回 true,这些类有：java.io.file,java.util.Date,java.lang.string,包装类（Integer,Double 等）

public class EqualsTest {
    public static void main(String[] args) {
        String s1=new String("sss");
        String s2=new String("sss");

        System.out.println(s1==s2);
        System.out.println(s1.equals(s2));
    }
}

//————————运行结果为——————
//false
//true

由此知道，在 String 中 equals()方法被进行了覆盖，使其意义变为比较两个对象的内容是否一致

Foreach

遍历数组并输出

double d[] = new double[10];
for(int i = 0; i < 10; i++)
    d[i] = Math.random();
for (double t : d)
    System.out.println(t);

for(int i : range(100))
{
    if(i == 74)break;
    else System.out.print(i);
}

标签

标签是后面根有冒号的标识符：
label1:

label1:
outer-iteration{
    inner-iteration{
        //...
        break;
        //...
        continue;
        //...
        continue label1;
        //...
        break label1;
    }
}

break 中断内部迭代，回到外部迭代。
continue 使执行点移回内部迭代的起始处
continue label1 中断内部迭代以及外部迭代，直接转到 label1 处，重新开始迭代过程。
break label1 也会中断所有迭代，并回到 label1，但并不重新开始迭代

构造器初始化之初始化顺序

在类的内部，变量定义的先后顺序决定了初始化的顺序。即使变量定义散布于方法定义之间，它们人就会在任何方法（包括构造器）被调用之前得到初始化。例如

class Window{
    Window(int marker){ print("Window(" + marker + ")"); }
}

clase House{
    Window w1 = new Window(1);
    House(){
        print("House()");
        w3 = new Window(33);
    }
    Window w2 = new Window(2);
    void f(){ print("f()") };
    Window w3 = new Window(3);
}

public class OrderOfInitialization{
    public static void main(String[] args){
        House h = new House();
        h.f();
    }
}

/* Output:
Window(1)
Window(2)
Window(3)
House()
Window(33)
f()
*/

显然定义的变量最先初始化，并且先定义的变量先初始化

instanceof

fun1 extends fun
fun1 instanceof fun //返回 true

super

super 指向父类的方法
例如重写了父类的方法，又想用父类原来的方法

this

this 指向本类的方法