进制表示

二进制0b 十进制 八进制0 十六进制0x

例：

1
2
3
int i  = 10;
int i2 = 010;  //八进制0 
int i3 = 0x10; //十六进制0x

out:

1
10 3 16

Equals

.equals方法可以用来判断字符串是否相等。

例：

1
2
3
4
String str = "Hello";
if(str.equals("Hello")){ //判断str是否与Hello相等
    ...
}

For each循环

for each element in a：循环A中的每一个元素。

主要用于数组或集合的增强型for循环。

例：

1
2
3
4
5
6
7
8
9
10
int[] nums = {10, 20, 30};

//For each
for(int x: nums){//遍历数组元素
    System.out.println(x);
}
//下面是用普通的for表示
for(int i = 0; i < 3; i++){
    System.out.println(nums[i]);
}

方法基础

基本定义

Java的方法跟其他语言的函数类似。

方法的结构：

1
2
3
4
5
6
修饰符 返回值类型 方法名(参数类型 参数名){
	...
	方法体
	...
	return 返回值
}

修饰符

访问控制修饰符

default (即默认，什么也不写）：在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
private：在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
public：对所有类可见。使用对象：类、接口、变量、方法
protected：对同一包内的类和其所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。实际上protected的成员，有两种可见：

  1. 父类的protected成员是包内可见的，并且对子类可见；
  2. 若子类与父类不在同一包中，那么在子类中，子类实例可以访问其从父类继承而来的protected方法，而不能访问父类实例的protected方法。

Father:

1
2
3
4
package cn.icewindy.base;
public class Father {
   protected void test(){}
}

Son:

1
2
3
4
5
6
7
8
9
10
11
12
package cn.icewindy.test;
import cn.icewindy.base.Father;
public class Son extends Father {
    public void test2(){
      	Father father = new Father();
      	father.test();//Compile Error
      	test2();//Compile OK 
    }
    public void test(){
		super.test();//Compile OK ，在override可以调用父类的protected方法
	}
}

非访问修饰符

static：用来修饰类方法和类变量。详细请看笔记（三）
final：用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
abstract：用来创建抽象类和抽象方法。
synchronized、volatile ：主要用于线程的编程。

方法的重载

在同一个类中，有相同的函数名字，但形参不同的函数。

例：构建一个比较大小的方法max

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public static void main(String[] args) {
	System.out.println(max(10,20));    //调用的是第一个方法
	System.out.println(max(10.0,20.0));//调用的是第二个方法
}
public static int max(int num1, int num2) {
	if (num1 > num2)
        return num1;
    else
    	return num2;
}
public static double max(double num1, double num2) {
    if (num1 > num2)
    	return num1;
    else
    	return num2;
}

方法重载的规则：

  1. 方法名称必须相同。
  2. 参数列表必须不同。
  3. 返回值类型可以相同，也可以不同。
  4. 仅仅返回值不同不构成方法的重载。

可变参数

Java支持传递同类型的可变参数给一个方法。

使用方法：

在方法声明中，在指定参数类型后加一个省略号(…) 。

1
参数类型... 参数名

注意：一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class DemoVarargs {
    public static void main(String[] args) {
        DemoVarargs demoVarargs = new DemoVarargs();
        demoVarargs.printMax(1, 2, 3, 4);
        demoVarargs.printMax(new double[]{1, 2, 3});
    }
    public static void printMax(double... nums){
        if(nums.length == 0){
            System.out.println("No argument passed");
            return;
        }
        double max = nums[0];
        for(double x: nums){
            if(x > max){
                max = x;
            }
        }
        System.out.println("max:" + max);
    }
}