JAVA核心语法

1. 标识符

标识符的命名规则：

1. 可以有大小写字母，0-9的阿拉伯数字，下划线_,美元符号$
2. 数字不能开头
3. 不能用Java中的50个关键字和保留字段的3个特殊值
4. Java严格区分大小写
5. 不能使用空格

标识符命名规范

1. 包所有字母都小写
2. 类名/接口名：所有单词首字母大写
3. 变量名/方法名：第一个首字母小写，其余单词首字母大写
4. 常量名：所有字母都大写，每个单词用_连接

---

 

2. 变量

概念：代码一块运行空间，使用变量名来访问和使用这块内存空间

变量的类型

1. 局部变量：定义在方法，构造方法，语句块中的变量，不能被修饰符修饰
2. 成员变量：定义在类之内，方法之外的变量，可以被访问修饰符修饰
3. 静态变量：定义在类之中，方法之外的变量，并且使用static关键字修饰
4. 参数变量：方法定义时声明的变量,作为调用该方法时传递给方法的值

accModiier returnType methodName(parameterType parameterName1,parameterType parameterName2)

• parameterType表示参数变量的类型
• parameterName表示参数变量的名字

变量的作用

1. 概念：一块内存中的数据空间的表示
2. 作用：保护数据

变量的注意事项

1. 变量应该先声明后使用
2. 变量要有初始值
3. 变量有作用域和生命周期

变量的作用域和生命周期

1. 局部变量：作用域只限于当前方法，构造方法，语句块中，保存在栈中，在变量所在的函数或模块被执行时动态创建，执行完时，变量对应的内存空间被释放
2. 成员变量：作用域为整个类
3. 静态变量：作用域为整个类
4. 参数变量：作用域只限于方法内部
5. 成员变量和静态变量都存储在静态存储区中，在编译时分配内存空间并进行初始化，在程序运行时一直存在，直到程序结束，变量对应的空间才被释放

常量

变量使用 final修饰的变量，常量在编译时就已经确定了他的值并且不能被修改

public final MAX_COUNT = 100

---

3. 数据类型

1. 基本数据类型

整数型：byte,short int,long

浮点型：float,double

字符型：char

布尔型：boolean

1. 基本数据类型的取值范围

• byte的取值范围是-128~127
• short的取值范围是-32768~32767
• int的取值范围是-2147483648~2147483647
• long的取值范围是-9223372036854775808~9223372036854775807（Long类型在写的时候要加上L，比如：long a =10000L;)

1. 引用数据类型

类：System，String

接口，数组

---

1. 类型转换

数据类型的大小排序：byte<shor,char<int<long<float<double

自动类型转换：必须满足转换前的数据类型的位数要低于转换后的数据类型

比如：float类型的变量可以自动转换成double类型的变量

强制类型转换：转换的数据必须是兼容的，

int i=123; byte = b = (byte)i;

隐式类型转换：整数的默认类型是int，小数的默认类型是double,在定义float类型的时候后面要跟上F或f

---

4. 运算符

4.1. 算术运算符

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

public class selfAddMinus{
    public static void main(String[] args){
        int a = 5;//定义一个变量；
        int b = 5;
        int x = 2*++a;//相当于2*6
        int y = 2*b++;//相当于2*5
        System.out.println("自增运算符前缀运算后a="+a+",x="+x);
        System.out.println("自增运算符后缀运算后b="+b+",y="+y);
    }
}

4.2.关系运算符

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

4.3.位运算符

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A | B = 0011 1101

A ^ B = 0011 0001

~A= 1100 0011

 

操作符	描述	例子
＆	如果相对应位都是1，则结果为1，否则为0	（A＆B），得到12，即0000 1100
|	如果相对应位都是 0，则结果为 0，否则为 1	（A | B）得到61，即 0011 1101
^	如果相对应位值相同，则结果为0，否则为1	（A ^ B）得到49，即 0011 0001
〜	按位取反运算符翻转操作数的每一位，即0变成1，1变成0。	（〜A）得到-61，即1100 0011
<<	按位左移运算符。左操作数按位左移右操作数指定的位数。	A << 2得到240，即 1111 0000
>>	按位右移运算符。左操作数按位右移右操作数指定的位数。	A >> 2得到15即 1111
>>>	按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。	A>>>2得到15即0000 1111

4.4.逻辑运算符

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

4.5.三元运算符

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

public class Test{
	public static void main(String[]args){
        int a,b;
        a=10;
        //如果a=1成立，那么b=20，否则b=30;
        b=(a==1)?20:30;
        System.out.println("Value of b is" +b);
        //如果a=10成立，那么b=20否则b=30；	
    	b=(a==10)?20:30;
    	System.out.println("Value of b is" +b);
        
    }
}

4.6instanceof运算符

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

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

如果instanceof左侧的对象实例，与右侧的类或接口类型相同，那么结果为真

class Vehicle {}
 
public class Car extends Vehicle {
   public static void main(String[] args){
      Vehicle a = new Car();
      boolean result =  a instanceof Car;
      System.out.println( result);
   }
}

4.7.运算符的优先级

()>算术运算符>关系运算符>逻辑运算符>三元运算符>赋值运算符

---

5. 流程控制结构

Java的程序执行顺序是按照代码书写从上到下从左到右依次执行的

5.1.条件语句

5.1.1 if语句

if(布尔表达式){
	//如果布尔表达式为true将执行的语句
    
}

5.1.2 if-else语句

if语句后面可以跟else语句，当if语句的布尔表达式值为false时，else语句会被执行

if(布尔表达式){
    //如果布尔表达式为true
}else{
	//如果布尔表达式为false
}

5.1.3 if...else if...else语句

if后面可以跟if-else语句，if语句至多有1个else语句，else语句必须在所有的else-if语句后面

if(布尔表达式1){
	//如果布尔表达式1true执行此代码
    
}else if(布尔表达式2){
    	//如果布尔表达式2true执行此代码
    
    
}else if(布尔表达式3){
        //如果布尔表达式3true执行此代码
}else{
    //如果以上布尔表达式都为false执行此代码
}

5.1.4 嵌套的if语句

if(布尔表达式 1){
   如果布尔表达式 1的值为true执行代码
   if(布尔表达式 2){
      如果布尔表达式 2的值为true执行代码
   }
}



public class Test {
 
   public static void main(String args[]){
      int x = 30;
      int y = 10;
 
      if( x == 30 ){
         if( y == 10 ){
             System.out.print("X = 30 and Y = 10");
          }
       }
    }
}

5.1.5 switch语句

switch case语句的语法格式

switch(expression){
    case value :
       //语句
       break; //可选
    case value :
       //语句
       break; //可选
    //你可以有任意数量的case语句
    default : //可选
       //语句
}

switch case的语法规则

1. switch的变量类型可以是byte，short，int，或者char，从JavaSE7开始，switch支持字符串同时，case标签必须为字符常量或字面量
2. switch语句可以同时拥有多个case语句，每个case后面跟一个要比较的值或冒号
3. case语句的值的数据类型要和变量的数据类型相同，而且只能是常量或者字面常量
4. 当变量的值与case语句的值相等，那么case语句开始执行，直到break才会跳出switch语句
5. case语句不必须包含break语句，如果没有break语句，程序会继续执行下一条case语句，直到出现break语句
6. switch语句可以包含一个default语句，该语句一般是switch语句的最后一句，default在没有case语句执行的时候执行，default不需要break语句

public class Test {
   public static void main(String args[]){
      //char grade = args[0].charAt(0);
      char grade = 'C';
 
      switch(grade)
      {
         case 'A' :
            System.out.println("优秀"); 
            break;
         case 'B' :
         case 'C' :
            System.out.println("良好");
            break;
         case 'D' :
            System.out.println("及格");
            break;
         case 'F' :
            System.out.println("你需要再努力努力");
            break;
         default :
            System.out.println("未知等级");
      }
      System.out.println("你的等级是 " + grade);
   }
}

5.1.6 if语句和switch语句的区别

1. if语句：表达式结果是boolean类型，常用于区间判断
2. switch语句：表达式类型不能是boolean，可以是 byte short int char，String，枚举类型的，常用于等值判断

5.2循环语句

循环的好处：代码简洁，易修改

 

5.2.1 while循环

while(布尔表达式){
	//循环内容
    
}
//只要布尔表达式为true，就会一直执行下去

5.2.2 do...while循环

do...while循环至少会执行一次

do{
    //代码语句
}while(布尔表达式)

布尔表达式在循环体的后面，所以语句在检测布尔表达式之前已经执行了

5.2.3 for循环

for循环执行的次数是在执行前就确定了

for(初始化;布尔表达式;更新){

    
}

for循环执行顺序：

1. 最先初始化变量，可以声明一种类型，但可以初始化一种或多种初始化循环变量，也可以是空语句
2. 然后检测布尔表达式的值，如果为true，循环体被执行，如果为false循环终止，开始执行循环体后面的语句
3. 执行一次循环后，更新循环控制变量
4. 再次检测布尔表达式，循环上面的过程

5.2.4 增强for循环

Java5 引入了一种主要用于数组的增强型 for 循环。

for(数据类型  变量名：要访问的数组名){
    //代码块
}

5.2.5 break关键字

break主要用于循环语句或者switch语句当中，用来跳出整个语句块

break跳出最里面的循环，并接着执行循环下面的语句

public class Test {
   public static void main(String[] args) {
      int [] numbers = {10, 20, 30, 40, 50};
 
      for(int x : numbers ) {
         // x 等于 30 时跳出循环
         if( x == 30 ) {
            break;
         }
         System.out.print( x );
         System.out.print("\n");
      }
   }
}


//输出   10   20;

5.2.6 continue关键字

continue适用于任何循环控制结构中，作用是让程序跳出本次循环，进入下次循环当中

在for循环当中，continue语句使程序跳转到更新语句

在while循环或do...while当中，程序立即跳转到布尔表达式的判断语句

public class Test {
   public static void main(String[] args) {
      int [] numbers = {10, 20, 30, 40, 50};
 
      for(int x : numbers ) {
         if( x == 30 ) {
        continue;
         }
         System.out.print( x );
         System.out.print("\n");
      }
   }
}

5.2.7 return关键字

return：从当前方法中跳出，返回到调用方法处继续执行

---

6. 方法

6.1 方法概述

概述：具有特点功能的代码块

• 方法是解决一类问题的步骤的有序组合
• 方法包含于类或对象中
• 方法在程序中被创建，在其他地方被引用
•  

6.2 方法的优点

• 使程序变的更简短而清晰
• 有利于程序维护
• 可以提高开发的效率
• 提高了代码的复用性

 

6.3 方法的定义

修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}

• 修饰符：修饰符，是可选的，告诉编译器如果调用该方法，定义了该方法的访问类型
• 返回值类型：方法可能会返回值，returnValueType是方法返回值的类型，有些方法执行体所需的操作，但没有返回值，在这种情况下，返回值类型是void
• 方法名：是方法的实际名称，方法名和参数列表共同构成方法签名
• 参数类型：参数像是一个占位符，当方法被调用时，传递值给参数，这个值被称为实参或变量，参数列表是指方法的参数类型，顺序和参数个数，方法可以不包括任何参数
• 方法包含具体的语句，定义该方法的功能

public static int age(int birthday){...}

 

6.4 方法的调用

Java支持两种调用方法的方式，根据方法是否返回值来选择

形参：方法用于外界声明，执行功能的时候，需要几个哪些类型的数据

实参：方法真正被调用的时候，传递给方法实实在在的数据

方法不能嵌套定义，但可以嵌套调用

 

6.5 方法的重载

方法重载可以让程序更清晰易读，执行密切相关任务的方法应该使用相同的名字

重载的方法必须拥有不同的参数列表，与返回值类型无关和修饰符无关

重载的所有方法必须在同一个类当中

6.6 可变参数

JDK 1.5 开始，Java支持传递同类型的可变参数给一个方法。

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

public class VarargsDemo {
    public static void main(String[] args) {
        // 调用可变参数的方法
        printMax(34, 3, 3, 2, 56.5);
        printMax(new double[]{1, 2, 3});
    }
 
    public static void printMax( double... numbers) {
        if (numbers.length == 0) {
            System.out.println("No argument passed");
            return;
        }
 
        double result = numbers[0];
 
        for (int i = 1; i <  numbers.length; i++){
            if (numbers[i] >  result) {
                result = numbers[i];
            }
        }
        System.out.println("The max value is " + result);
    }
}

6.7 构造方法

当一个对象被创建时候，构造方法用来初始化该对象。构造方法和它所在类的名字相同，但构造方法没有返回值。

不管你是否自定义构造方法，所有的类都有构造方法，因为 Java 自动提供了一个默认构造方法，默认构造方法的访问修饰符和类的访问修饰符相同(类为 public，构造函数也为 public；类改为 protected，构造函数也改为 protected)。

一旦你定义了自己的构造方法，默认构造方法就会失效。

6.8 finalize()方法

Java 允许定义这样的方法，它在对象被垃圾收集器析构(回收)之前调用，这个方法叫做 finalize( )，它用来清除回收对象。

例如，你可以使用 finalize() 来确保一个对象打开的文件被关闭了。

在 finalize() 方法里，你必须指定在对象销毁时候要执行的操作。

public class FinalizationDemo {  
  public static void main(String[] args) {  
    Cake c1 = new Cake(1);  
    Cake c2 = new Cake(2);  
    Cake c3 = new Cake(3);  
      
    c2 = c3 = null;  
    System.gc(); //调用Java垃圾收集器
  }  
}  
 
class Cake extends Object {  
  private int id;  
  public Cake(int id) {  
    this.id = id;  
    System.out.println("Cake Object " + id + "is created");  
  }  
    
  protected void finalize() throws java.lang.Throwable {  
    super.finalize();  
    System.out.println("Cake Object " + id + "is disposed");  
  }  
}

Java的内存回收一般是由JVM自动完成 如果想要手动回收Java的内存可以使用finalize方法

---