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      位赋值运算     &=、|=、<<=、>>=、>>>=