java修饰符$_JAVA基础语法—标识符、修饰符、运算符

Java标识符：

标识符就是用于Java程序中变量，类，方法等命名的符号

标识符的命名规则：

(1)标识符必须以字母、下划线_ 、美元符$开头。

(2)标识符其它部分可以是字母、下划线“_”、美元符“$”和数字的任意组合。

(3)Java 标识符大小写敏感，且长度无限制。

(4)不可以是Java的关键字。

一般在进行项目时，包名采用域名倒置，如：com.changcheng.DAO;

表示类名的标识符首字母大写；如：Person；

表示方法和变量的标识符用小写字母开始，后面的描述性词语以大写开始；

一般类名与方法名采用见明知义的命名方法，尽量用英文，避免用中文拼音。

Java修饰符：

JAVA语言提供了很多修饰符，主要分为两大类：

1、 访问修饰符：

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。

Java 支持 4 种不同的访问权限:

default (即缺省，什么也不写): 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。

private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类(外部类)

public : 对所有类可见。使用对象：类、接口、变量、方法

protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类(外部类)。

我们可以通过下表来更清楚的了解访问修饰符：

修饰符

当前类

同一包内

子孙类(同一包)

子孙类(不同包)

其他包

public

Y

Y

Y

Y

Y

protected

Y

Y

Y

Y/N(详见后文)

N

default

Y

Y

Y

N

N

private

Y

N

N

N

N

默认访问修饰符-不使用任何关键字

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

如下，变量和方法的声明可以不使用任何修饰符。

String a=”123”;

Boolean processOrder(){

return ture;

}

公有访问修饰符-public

被声明为public的类、方法、构造方法以及接口可以被任何类访问。

但是不同包需要导包；

同时类所有的公有方法和变量都能被其他子类继承。

Java程序中的main()方法必须设为公有的，否则，Java解释器不能运行该类

私有访问修饰符-private

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

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

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

受保护的访问修饰符-protected

protected修饰的变量和方法可以被当前类和同一个包内的类对象调用，而子孙类中，子类与基类在同一个包中时被声明为 protected 的变量、方法和构造      器能被同一个包中的任何其他类访问；子类与基类不在同一个包中时，子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的protected方法。

protected 可以修饰数据成员，构造方法，方法成员，不能修饰类(内部类除外)。

接口及接口的成员变量和成员方法不能声明为 protected。

非访问修饰符

为了实现一些其他的功能，Java 也提供了许多非访问修饰符。

static 修饰符，用来修饰类方法和类变量。

final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。

abstract 修饰符，用来创建抽象类和抽象方法。

synchronized 和 volatile 修饰符，主要用于线程的编程。

static修饰符

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

2、修饰方法：static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。

final修饰符

final修饰符修饰变量时，被修饰的变量就不能被重新赋值

被 final 修饰的实例变量必须显式指定初始值。

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

final修饰符修饰方法时，被修饰的方法可以被子类继承，但是不能被子类修改，声明final方法的主要目的是防止该方法的内容被修改。

final修饰类时，被修饰的类不能被继承。

abstract修饰符

抽象类：

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

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

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

抽象方法

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

抽象方法不能被声明成 final 和 static。

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

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

抽象方法的声明以分号结尾，例如：public abstract sample();。

synchronized 修饰符

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

transient 修饰符

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

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

volatile 修饰符

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

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

Java运算符

算数运算符_1

常见操作

运算符   运算规则         范例           结果

+           正号                 +3                3

+            加                   2+3               5

+         连接字符串     “中”+“国”       “中国”

-           负号                int a=3;-a       -3

-            减                    3-1                 2

*            乘                    2*3                6

/            除                    5/2                 2

%           取模                5/2                 1

++           自增       int a=1;a++/++a      2

--           自减  int b=3;a--/--a        2

注意事项

1、加法运算符在连接字符串时要注意，只有直接与字符串相加才会转成字符串。

2、除法“/”当两边为整数时，取整数部分，舍余数。当其中一边为浮点型时，按正常规则相除。

3、“%”为整除取余符号，小数取余没有意义。结果符号与被取余符号相同。

4、整数做被除数，0不能做除数，否则报错。

5、小数做被除数，整除0结果为Infinity，对0取模结果为NaN

6、 ++运算符，会在原有值的基础上自增1

7、 --运算符，会在原有值的基础上自减1。

8、++,--运算符后置时，先使用变量a原有值参与运算操作，运算操作完成后，变量a的值自增1或者自减1；

9、++，--运算符前置时，先将变量a的值自增1或者自减1，然后使用更新后的新值参与运算操作。

赋值运算符

赋值运算符的使用

运算符 运算规则           范例                   结果

=                   赋值 int a=2                  2

+=               加后赋值         int a=2，a+=2       4

-=                减后赋值         int a=2，a-=2        0

*=                乘后赋值 int a=2，a*=2        4

/=              整除后赋值       int a=2，a/=2        1

%=             取模后赋值 int a=2，a%=2      0

比较运算符

比较运算符的使用

运算符          运算规则 范例 结果

==                相等于 4==3              False

!=                 不等于 4!=3               True

<                  小于 4<3                False

>                  大于               4>3                True

<=                小于等于4<=3              False

>=                大于等于        4>=3              True

逻辑运算符

逻辑运算符的使用

运算符      运算规则        范例              结果

&                 与 false&true         False

|                  或false|true          True

^                 异或            true^flase         True

!                  非 !true                  Flase

&&               短路与 false&&true       False

||                  短路或 false||true          True

规律小结:

短路与&&:参与运算的两边数据，有false，则运算结果为false；

l 短路或||:参与运算的两边数据，有true，则运算结果为true；

l 逻辑非! : 参与运算的数据，原先是true则变成false，原先是false则变成true。

三元运算符

格式:

(条件表达式)？表达式1：表达式2；

实例：

方式一：

System.out.println( 3>2 ? “正确” : “错误” );

// 三元运算符运算后的结果为true，运算结果为表达式1的值“正确”，然后将结果“正确”，在控制台输出打印

方式二：

int a = 3;

int b = 4;

String result = (a==b) ? “相等” : “不相等”;

//三元运算符运算后的结果为false，运算结果为表达式2的值“不相等”，然后将结果赋值给了变量result

方式三：

int n = (3>2 && 4>6) ? 100 : 200;

//三元运算符运算后的结果为false，运算结果为表达式2的值200,然后将结果200赋值给了变量n

运算符优先级

优先级     描述         运算符

1         括号          ()、[]

2       正负号         +、-

3    自增自减,非    ++、--、!

4     乘除，取余     *、/、%

5        加减             +、-

6      移位运算      <>、>>>

7      大小关系     >、>=、

8      相等关系     ==、!=

9        按位与         &

10       按位异或       ^

11        按位或          |

12        逻辑与         &&

13        逻辑或          ||

14       条件运算       ?:

15       赋值运算       =、+=、-=、*=、/=、%=

16      位赋值运算     &=、|=、<<=、>>=、>>>=