本文主要是介绍Java 入门基础，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

1.Java基础语法：

1.标识符：

由字母，下划线，美元符号和数字组成
第一个字符不可以是数字
不可以是关键字

2.修饰符

Java可以使用修饰符来修饰类中方法和属性
访问控制修饰符 : public , protected, private
非访问控制修饰符 : final, abstract, static

3.基本语法

1. 类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。
2. 方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。
3. 源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记 Java 是大小写敏感的），文件名的后缀为 .java
4. 主方法入口：所有的 Java 程序由 public static void main(String[] args) 方法开始执行。
5. 注释：单行：“//” 多行：“/* */”

2.Java 两大数据类型: 基本数据类型和引用数据类型

1.基本数据类型：

1.布尔类型：

常量：true false
变量：使用关键字boolean来声明变量，只有两个取值：true 和 false；
默认值是 false；

2.整数类型：

1 . byte型：分配1字节内存，无常量，变量取值范围：-128（-2^7） 到127（2^7-1） 默认值是 0
2. short型：分配2字节内存，无常量，变量取值范围：最小值是 -32768（-2^15）；最大值是 32767（2^15 - 1）；
3. int 型：分配4字节内存
4. long型：分配8字节内存 默认值是 0L；

3.浮点类型：

1. 单精度浮点型 float
   常量：数字后面必须要有f或F
   变量：保留8位有效数字
   默认值是 0.0f；
2. 双精度浮点型 double
   常量：数字后面可以有d或D
   变量：保留16位有效数字(精度的区别)
   默认值是 0.0d；
   Float和Double以科学记数法的形式输出的，结尾的"E+数字"表示E之前的数字要乘以10的多少次方。
   比如3.14E3就是3.14 × 103 =3140，3.14E-3 就是 3.14 x 10-3 =0.00314

4.字符类型：

常量用单引号括起来，里面只可以有一个字符
分2字节内存，取值0~65535
char x='a' 等同于char x=97;
内存中a中存储的是97，就是字符a在Unicode中的排序位置
转义字符：
换行：/n
单引号：'
双引号：''
反斜线：\
回车：\r

5.类型转换运算：

按精度由低到高分级：byte short char int long float double

1.当级别高的赋值给级别低的：要强制类型转换；

（要转换为的类型）要转换的值

1. 当一个double型的常量赋值给float变量时：float x = (float)12.4;
2. 转换过程中可能导致溢出或损失精度，例如：
   int i =128;
   byte b = (byte)i;
   因为 byte 类型是 8 位，最大值为127，所以当 int 强制转换为 byte 类型时，值 128 时候就会导致溢出
3. 浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如：
   (int)23.7 == 23;
   (int)-45.89f == -45

2. 当级别低的赋值给级别高的： 会自动类型转换；

3. 隐含强制类型转换:

1、 整数的默认类型是 int
2. 小数默认是 double 类型浮点型，在定义 float 类型时必须在数字后面跟上 F 或者 f

2. 引用类型

1. 引用类型指向一个对象，指向对象的变量是引用变量。
2. 对象、数组都是引用数据类型。
3. 所有引用类型的默认值都是null。

3.Java 常量

1. 在 Java 中使用 final 关键字来修饰常量，声明方式和变量类似：
   final double PI = 3.1415927;
   通常使用大写字母表示常量
2. byte、int、long、和short都可以用十进制、16进制以及8进制的方式来表示
   当使用字面量的时候，前缀 0 表示 8 进制，而前缀 0x 代表 16 进制, 例如：
   int d = 100;
   int o = 0144;
   int h= 0x64;
3. 字符串常量也是包含在两个引号之间的字符序列
   ""This is in quotes""
4. 字符串常量和字符常量都可以包含任何Unicode字符。
   char a = '\u0001';
   String a = "\u0001";

3.Java 变量类型

类变量：独立于方法之外的变量，用 static 修饰。
实例变量：独立于方法之外的变量，不过没有 static 修饰。
局部变量：类的方法中的变量

1. 所有的变量在使用前必须声明，可以使用逗号隔开来声明多个同类型变量
   有些包含了初始化过程
   int a, b, c; // 声明三个int型整数：a、 b、c
   int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值
   byte z = 22; // 声明并初始化 z
   String s = "runoob"; // 声明并初始化字符串 s
   double pi = 3.14159; // 声明了双精度浮点型变量 pi
   char x = 'x'; // 声明变量 x 的值是字符 'x
2. 局部变量
   局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；
   局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。
3. 实例变量
   实例变量在对象创建的时候创建，在对象被销毁的时候销毁；
   实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
   对象的 实例变量，是自己独有的
4. 类变量（静态变量）
   在类加载时就声明了 ；
   在类中以 static 关键字声明 private static double salary;
   用此类创建的对象共享类变量

4.Java 运算符

1. 算术运算符：+ - * / %
2. 自增自减运算符:
   前缀自增自减法(++a,--a): 先进行自增或者自减运算，再进行表达式运算。
   后缀自增自减法(a++,a--): 先进行表达式运算，再进行自增或者自减运算
3. 关系运算符: > >= < <= == != 返回布尔型
4. 逻辑运算符：&& || ! 返回布尔型
   优先级：先&&再||
   短路逻辑运算符:当使用与逻辑运算符时，在两个操作数都为true时，结果才为true，
   但是当得到第一个操作为false时，其结果就必定是false，这时候就不会再判断第二个操作了。
5. 赋值运算符:
   = 右边赋值给左边
   += a+=2 等同于 a=a+2
6. 条件运算符
   条件表达式 ？ 变量1 ： 变量2
   若条件表达式成立，就返回变量1，否则返回变量2
   注意表达式有返回值

5.Java 循环结构

1. while( 布尔表达式 ) {
   //循环内容
   }
2. do {
   //代码语句
   }while(布尔表达式);
3. for(初始化; 布尔表达式; 更新) {
   //代码语句
   }

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

for(声明语句 : 表达式)
{
//代码句子
}
声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

public class Test {
   public static void main(String args[]){
      int [] numbers = {10, 20, 30, 40, 50};
      for(int x : numbers ){
         System.out.print( x );
         System.out.print(",");
      }
      System.out.print("\n");
      String [] names ={"James", "Larry", "Tom", "Lacy"};
      for( String name : names ) {
         System.out.print( name );
         System.out.print(",");
      }
   }
}
//10,20,30,40,50,
//James,Larry,Tom,Lacy,

break 关键字

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

continue 关键字

让程序立刻跳转到下一次循环的迭代。

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");
      }
   }
}// 10 20 40 50

6. Java 的switch case 语句

判断一个变量与一系列值中某个值是否相等，

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

1. case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。
2. 当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。
3. switch 语句可以包含一个 default 分支，该分支一般是 switch 语句的最后一个分支（可以在任何位置，但建议在最后一个）。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。
4. switch case 执行时，一定会先进行匹配，匹配成功返回当前 case 的值，再根据是否有 break，判断是否继续输出，或是跳出判断。

这篇关于Java 入门基础的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！