Java基础知识（3）- Java 修饰符、运算符

 

1. Java 修饰符

Java 语言提供了很多修饰符，主要分为以下两类： 访问控制修饰符，非访问控制修饰符

 

1) 访问控制修饰符

Java 中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持4种不同的访问权限。

(1) default - 默认访问修饰符(不使用任何关键字):

使用默认访问修饰符声明的变量和方法，同一个包内的类可访问。接口里的变量都隐式声明为 ​public static final​, 而接口里的方法默认情况下访问权限为 ​public​。

(2) private - 私有访问修饰符

私有访问修饰符是最严格的访问级别，被声明为 private 的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为 private。

声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。

Private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。

(3) protected - 受保护的访问修饰符

被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问，也能够被不同包中的子类访问。

Protected 访问修饰符不能修饰类和接口，方法和成员变量能够声明为 protected，但是接口的成员变量和成员方法不能声明为 protected。

子类能访问 Protected 修饰符声明的方法和变量，这样就能保护不相关的类使用这些方法和变量。

(4) public - 公有访问修饰符

被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。

如果几个相互访问的 public 类分布在不同的包中，则需要导入相应 public 类所在的包。由于类的继承性，类所有的公有方法和变量都能被其子类继承。

访问控制和继承, 请注意以下方法继承的规则：

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

(5) 访问控制权限列表

	本类	本包	子类	外部包
public	Y	Y	Y	Y
protected	Y	Y	Y	X
default	Y	Y	X	X
private	Y	X	X	X

 

实例：

interface Modifier {

    String name = "modifier name";   // 接口里的变量都隐式声明为 ​public static final​, 需要初始化
    //protected int a = 1;  // 接口的成员变量和成员方法不能声明为 protected
    //private int b = 2;    // 接口的成员变量和成员方法不能声明为 private

    String getName();       // 接口里的方法默认情况下访问权限为 ​public​

}

class ModifierImpl implements Modifier {

    String label = "modifier label";    // default 访问权限, 同一个包内的类可访问
    protected int x = 3;    // 同一个包中的其他类能访问，也能够被不同包中的子类访问
    private int y = 4;      // 同一个包中的其他类不能访问
    public int z = 5; 

    @Override
    public String getName() {
        return name;
    }

}

public class App {
    public static void main( String[] args ) {          
        ModifierImpl modifierImpl = new ModifierImpl();
        System.out.println("Name is: " + modifierImpl.getName());
        System.out.println("Label is: " + modifierImpl.label);
        System.out.println("x is: " + modifierImpl.x);
        //System.out.println("y is: " + modifierImpl.y);
        System.out.println("z is: " + modifierImpl.z);
    }
}

输出：

Name is: modifier name
Label is: modifier label
x is: 3
z is: 5 

 

　　2) 非访问控制修饰符

(1) static 修饰符 (静态)

a) 静态变量：

　　static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。静态变量也被称为类变量。局部变量不能被声明为static变量。

b) 静态方法：

　　static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量，也不能被子类重写 (@Override)。

　　对类变量和方法的访问可以直接使用 ​classname.variablename​ 和 ​classname.methodname​ 的方式访问。

(2) final 修饰符

　　a) final 变量：

　　　　final 变量能被显式地初始化并且只能初始化一次。被声明为 final 的对象的引用不能指向不同的对象。但是 final 对象里的数据可以被改变。也就是说 final 对象的引用不能改变，但是里面的值可以改变。

　　　　final 修饰符通常和 static 修饰符一起使用来创建类常量。

　　b) final 方法：

　　　　类中的 Final 方法可以被子类继承，但是不能被子类重写(@Override)。 声明 final 方法的主要目的是防止该方法的内容被重写。

　　c) final 类：

　　　　final 类不能被继承，没有类能够继承 final 类的任何特性。

(3) abstract 修饰符

　　a) 抽象类：

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

　　　　一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。

　　　　抽象类可以包含抽象方法和非抽象方法。

　　b) 抽象方法

　　　　抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。抽象方法不能被声明成 final 和 static。

　　　　任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。

　　　　如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。

　　　　抽象方法的声明以分号结尾。

(4) synchronized 修饰符

　　synchronized 关键字声明的方法同一时间只能被一个线程访问。Synchronized 修饰符可以应用于四个访问修饰符。

(5) transient 修饰符

　　序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机 (JVM) 跳过该特定的变量。

　　该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。

(6) volatile 修饰符

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

　　一个 volatile 对象引用可能是 null。

 

　　实例：

class Modifier2 {

    static String name = "modifier2 name";
    static String label = "modifier2 label";
    String label2 = "modifier2 label 2";

    static String getName() {
        return name;
    }

    static String getLabel() {
        return label;
        //return label2;   // 静态方法不能使用类的非静态变量
    }

    String getLabel2() {
        return label2;
    }

}

// final 修饰的 Modifier3 类不能被继承
final class Modifier3 extends Modifier2 {

    static String label = "modifier3 label";

    // final 方法可以被子类继承，但是不能被子类重写(@Override)
    @Override
    final String getLabel2() {
        return label;
    }

}    

public class App {
    public static void main( String[] args ) {
        Modifier3 modifier3 = new Modifier3();
        System.out.println("Name is: " + modifier3.getName());
        System.out.println("Label is: " + modifier3.getLabel());
        System.out.println("Label2 is: " + modifier3.getLabel2());     
    }
}

　　输出：

　　　　Name is: modifier2 name
　　　　Label is: modifier2 label
　　　　Label2 is: modifier3 label

2. Java 运算符

　　计算机的最基本用途之一就是执行数学运算，作为一门计算机语言，Java也提供了一套丰富的运算符来操纵变量。

　　1） 算术运算符

算术运算符用在数学表达式中，它们的作用和在数学中的作用一样。下表列出了所有的算术运算符。

操作符   描述
+     加法 - 相加运算符两侧的值
-      减法 - 左操作数减去右操作数
*      乘法 - 相乘操作符两侧的值
/      除法 - 左操作数除以右操作数
％   取模 - 左操作数除以右操作数的余数
++  自增 - 操作数的值增加1
--    自减 - 操作数的值减少1

　　2） 关系运算符

运算符   描述
==  检查如果两个操作数的值是否相等，如果相等则条件为真。
!=   检查如果两个操作数的值是否相等，如果值不相等则条件为真。
>    检查左操作数的值是否大于右操作数的值，如果是那么条件为真。
<    检查左操作数的值是否小于右操作数的值，如果是那么条件为真。
>=  检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。
<=  检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。

3）位运算符

操作符   描述
＆     按位与操作符，当且仅当两个操作数的某一位都非0时候结果的该位才为1。
|        按位或操作符，只要两个操作数的某一位有一个非0时候结果的该位就为1。
^       按位异或操作符，两个操作数的某一位不相同时候结果的该位就为1。
〜     按位补运算符翻转操作数的每一位。
<<    按位左移运算符。左操作数按位左移右操作数指定的位数。
>>    按位右移运算符。左操作数按位右移右操作数指定的位数。
>>>  按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。

4）逻辑运算符

操作符   描述
&&  称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。
| |    称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。
！   称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。

5）赋值运算符

操作符   描述
=        简单的赋值运算符，将右操作数的值赋给左侧操作数
+ =     加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数
- =      减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数
* =      乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数
/ =      除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数
％=    取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数
<< =  左移位赋值运算符
>> =  右移位赋值运算符
＆=    按位与赋值运算符
^ =     按位异或赋值操作符
| =      按位或赋值操作符

6）条件运算符（?:）

　　条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。

　　variable x = (expression) ? value if true : value if false

7）instanceof 运算符

　　该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。

　　instanceof 运算符使用格式如下：

　　( Object reference variable ) instanceof (class/interface type)

8）Java运算符优先级

　　　　下表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部。

类别	操作符	关联性
后缀	() [] . (点操作符)	从左到右
一元	! + - ~ ++ --	从右到左
乘性	* / ％	从左到右
加性	+ -	从左到右
移位	<< >> >>>	从左到右
关系	< <= > >= instanceof	从左到右
相等	== !=	从左到右
按位与	＆	从左到右
按位异或	^	从左到右
按位或	|	从左到右
逻辑与	&&	从左到右
逻辑或	||	从左到右
条件	?:	从左到右
赋值	= += -= *= /= ％= |= ^= ~= <<= >>= >>>=	从右到左
逗号	,	从左到右

 

　　实例：

public class App {
    public static void main( String[] args ) {

        int a = 10;
        int b = 20;
        int c = 25;
        int d = 25;

        System.out.println("算术运算符:");
        System.out.println("a = " + a + ", b = " + b + ", c = " + c + ", d = " + d);
        System.out.println("a + b = " + (a + b) );
        System.out.println("a - b = " + (a - b) );
        System.out.println("a * b = " + (a * b) );
        System.out.println("b / a = " + (b / a) );
        System.out.println("b % a = " + (b % a) );
        System.out.println("c % a = " + (c % a) );
        System.out.println("a++   = " +  (a++) );
        System.out.println("a--   = " +  (a--) );
        System.out.println("d++   = " +  (d++) );
        System.out.println("d     = " +  d);
        System.out.println("++d   = " +  (++d) );

        System.out.println("关系运算符:");
        System.out.println("a == b = " + (a == b) );
        System.out.println("a != b = " + (a != b) );
        System.out.println("a > b = " + (a > b) );
        System.out.println("a < b = " + (a < b) );
        System.out.println("b >= a = " + (b >= a) );
        System.out.println("b <= a = " + (b <= a) );

        System.out.println("位运算符:");
        a = 60;     // 60 = 0011 1100
        b = 13;     // 13 = 0000 1101 
        c = 0;
        System.out.println("a = " + a + ", b = " + b + ", c = " + c);
        c = a & b;       // 12 = 0000 1100 
        System.out.println("a & b = " + c );
        c = a | b;       // 61 = 0011 1101 
        System.out.println("a | b = " + c );
        c = a ^ b;       // 49 = 0011 0001 
        System.out.println("a ^ b = " + c );
        c = ~a;          //-61 = 1100 0011 
        System.out.println("~a = " + c );
        c = a << 2;     // 240 = 1111 0000 
        System.out.println("a << 2 = " + c );
        c = a >> 2;     // 215 = 1111
        System.out.println("a >> 2  = " + c );
        c = a >>> 2;     // 215 = 0000 1111 
        System.out.println("a >>> 2 = " + c );

        System.out.println("逻辑运算符:");
        boolean x = true;
        boolean y = false;
        System.out.println("x = " + x + ", y = " + y );
        System.out.println("x && y = " + (x && y));
        System.out.println("x || y = " + (x || y) );
        System.out.println("!(x && y) = " + !(x && y));

        System.out.println("赋值运算符:");
        a = 10;
        b = 20;
        c = 0;
        System.out.println("a = " + a + ", b = " + b + ", c = " + c);
        c = a + b;
        System.out.println("c = a + b = " + c );
        c += a ;
        System.out.println("c += a  = " + c );
        c -= a ;
        System.out.println("c -= a = " + c );
        c *= a ;
        System.out.println("c *= a = " + c );
        a = 10;
        c = 15;
        System.out.println("a = " + a + ", b = " + b + ", c = " + c);
        c /= a ;
        System.out.println("c /= a = " + c );
        a = 10;
        c = 15;
        System.out.println("a = " + a + ", b = " + b + ", c = " + c);
        c %= a ;
        System.out.println("c %= a  = " + c );
        c <<= 2 ;
        System.out.println("c <<= 2 = " + c );
        c >>= 2 ;
        System.out.println("c >>= 2 = " + c );
        c >>= 2 ;
        System.out.println("c >>= a = " + c );
        c &= a ;
        System.out.println("c &= a = " + c );
        c ^= a ;
        System.out.println("c ^= a = " + c );
        c |= a ;
        System.out.println("c |= a = " + c );

    }
}

　　输出：

算术运算符:
a = 10, b = 20, c = 25, d = 25
a + b = 30
a - b = -10
a * b = 200
b / a = 2
b % a = 0
c % a = 5
a++ = 10
a-- = 11
d++ = 25
d = 26
++d = 27

关系运算符:
a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false

位运算符:
a = 60, b = 13, c = 0
a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 2 = 15
a >>> 2 = 15

逻辑运算符:
x = true, y = false
x && y = false
x || y = true
!(x && y) = true

赋值运算符:
a = 10, b = 20, c = 0
c = a + b = 30
c += a = 40
c -= a = 30
c *= a = 300
a = 10, b = 20, c = 15
c /= a = 1
a = 10, b = 20, c = 15
c %= a = 5
c <<= 2 = 20
c >>= 2 = 5
c >>= a = 1
c &= a = 0
c ^= a = 10
c |= a = 10