标签：break   单元   结束   for   transient   constant   Java变量   display   byte   

1.基本

1.1注释

• 平时我们编写代码，在代码量比较少的时候，我们还可以看懂自己写的，但是当项目结构一旦复杂起来，我们就需要用到注释了。
• 只是并不会被执行，注释是给人看的
• 书写注释是一个非常好的习惯

• 注释的分类
  • 单行注释
  • 多行注释
  • 文档注释

1.1.1单行注释

以 // 开始，只支持单行，不支持换行！！！

就比如我们要给HelloWorld写注释

public class HelloWorld{
    public static void main(String[] args){
        //打印输出一个HelloWorld！
        System.out.println("HelloWorld!");//打印输出一个HelloWorld！
    }
}

注意，不可以这样使用：

public class HelloWorld{
    public static void main(String[]args){
        //在控制台打印出Hello！World！System.out.println("Hello!World!");
    }
}

• 因为这样代码被注释掉了，注释掉的代码永远不会被执行，这是一条空代码。

1.1.2多行注释

以 / 开始，以 / 结束

可以这样使用：

public class HelloWorld{
    public static void main(String[]args){
        /*
        在控制台打出Hello！World！
        向世界呐喊！
        */
        System.out.println("Hello!World!");
    }
}

但是不可以这样使用：

public class HelloWorld{
    public static void main(String[]args){
                                            /*
        System.out.println("Hello!World!");   在控制台打出Hello！World！
                                              向世界呐喊！
                                            */
    }

因为这样代码也是被注释掉了，注释掉的代码永远不会被执行，这也是一条空代码。

1.1.3文档注释(JavaDoc)

以 /** 开始，以 */ 结束

• 注意：文档注释是有功能的注释，会被识别

• JavaDoc命令是用来生成自己的API文档的

• 参数信息

  • @author 作者名
  • @version 版本号
  • @since 指明需要最早使用的jdk版本
  • @param 参数名
  • @return返回值情况
  • @throws 异常抛出情况

1.2标识符

• Java中所有的组成部分都需要名字。类名，变量名及方法名都被称为标识符。

注意

所有的标识符都应该以字母（A-Z或者a-z），美元符（$）、或者下划线（_），开始，如：

int c1=0;//合法
int 1c=0;//不合法
int $1=0;//合法
int _1=0;//合法
int *1=0；//不合法
int #1=0；//不合法
int 好=0; //合法，但不建议使用中文命名，也不建议使用拼音，因为特别low。

• 首个字符之后可以是字母（A-Z或者a-z），美元符（$）、或者下划线（_）的任意组合，如：

  int c1=0;//合法
  int Ac1=0;//合法
  int $a1=0;//合法
  int _1765=0;//合法
  int _1#=0；//不合法
  int _1*=0；//不合法
  

• Java对于大小写是敏感的，如：

  int h1=0;
  int H1=0;
  //它们俩是不一样的
  

1.3 关键字

——Java中所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符

——切记不可以用关键字给变量名，类名，方法名命名。

用于定义数据类型的关键字

用于定义数据类型的关键字

用于定义流程控制的关键字

用于定义访问权限修饰符的关键字

用于定义类，函数，变量修饰符的关键字

用于定义类与类之间关系的关键字

用于定义建立实例及引用实例，判断实例的关键字

用于异常处理的关键字

用于包的关键字

其他修饰符关键字

2.数据类型操作

2.1数据类型

• byte的范围

  最小值：-128

  最大值：127

• short的范围

  最小值：-32768

  也就是 -2 的 15 次方。

  最大值：32767

  也就是 2 的 15 次方减 1。

• int的范围

  最小值：-2147483648

  也就是 -2 的 31 次方。

  最大值：2147483647

  也就是 2 的 31 次方减 1。

• long的范围

  最小值：-9223372036854775808L

  也就是 -2 的 63 次方。

  最大值：9223372036854775807L

  也就是 2 的 63 次方减 1。

  ——long数值后面要有一个（ l 或 L）来声明这是一个 long 类型，但是建议使用大写的L，因为···

  

• float的范围

  最小值：0.0000000000000000000000000000000000000000000014

  也就是 1.4 乘以 10 的 -45 次方。

  最大值：340282350000000000000000000000000000000

  也就是 3.4028235 乘以 10 的 38 次方。

  ——float数值后面要有一个（f 或 F）来声明这是一个 float 类型（这里大小写就无所谓了）

• double的范围

  最小值：4.9E-324

  也就是：4.9 乘以10 的 -324 次方。

  最大值：1.7976931348623157E308

  也就是 1.7976931348623157 这个数的小数点后移308位。

• boolean的范围：

  只有 true （对）和 false （错）。

2.2类型转换

因为Java是强类型语言，所以要进行运算时，要用到类型转换。

低-------------------------------------------------------------------->高

char-----byte---->short---->int---->long---->float---->double

public class Test{
    public static void main(String [] args){
        //由高到低——强制转换：(类名)变量名;
        //char 和 byte 或 short 互转都需要强制转换
        int a1 = 128;
        byte a2 =(byte)a;
        System.out.println(b);  //-128 byte的最大值为127，而a的值为128，这时候强制转换，会出现内存溢出的问题。
        //由低到高——自动转换
        byte b1=120;
        int b2=b1;
        System.out.println((int)31.4);   //31
        System.out.println((int)56.45F); //56
    }
}

注意事项：

1. 不能对布尔值进行转换。
2. 不能把对象类型转换为不相干的类型。
3. 在高容量转低容量的时候，强制转换。
4. 转换的时候可能存在内存溢出，或者精度问题。

3.数据分别

3.1变量

3.1.1变量基本说明

• 顾名思义，变量就是会变化的量。
• Java是一种强类型语言，每个变量必须声明其类型。
• Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

//数据类型 变量名=值;可以使用逗号隔开来声明多个变量。
//如：
int a,b,c,d;
int a=1,b=2,c=3,d=4;
//为了提升程序的可读性，不建议这样声明变量。
//这样声明：
int a = 1;
int b = 2;
int c = 3;
int d = 4;

注意事项：

1. 每个变量都有类型，类型可以是基本类型，也可以是引用类型。
2. 变量名必须是合法标识符。
3. 变量声明是一条完整的语句，因此每一个声明都必须一分号结束。

3.1.2变量的作用域

• Java中变量分为：类变量，实例变量，局部变量。

public class Test{
    static int a=0;    //类变量
    String str = "Hello World!";//实例变量：从属于对象
    String name;  //实例变量如果不自行初始化，会变成这个类型的默认值
    int age;
    public static void main(String [] args){
        int b = 0;    //局部变量
        Test test = new Test(); //使用实例变量
        System.out.println(Test.name);//null 除了基本类型其余的都是默认值null
        System.out.println(Test.age); //0   
    }
}

3.1.3变量的命名规范：

1. 驼峰原则：除了第一个单词以外，后面的单词首字母大写如：goodBoy
2. 所有变量、方法、类名：见名知意
3. 类成员变量：首字母小写和驼峰原则
4. 局部变量：首字母小写和驼峰原则
5. 常量：大写字母和下划线：MAX_VALUE
6. 类名：首字母大写和驼峰原则
7. 方法名：首字母小写和驼峰原则

3.2常量

• 常量(Constant):初始化(initialize)后不能再改变值！不会变动的值。
• 所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。

//final 常量名 = 值;
final double PI = 3.1415926535;  //常量名一般使用大写字符。

//修饰符不存在先后顺序
static final double PI = 3.14;
//和
final static double PI = 3.14;
//是一样的

4.运算

4.1运算符

4.1.1运算符

• 算数运算符：+ - * / % ++ –

• 赋值运算符：=

• 关系运算符：> < >= <= == !=

• 逻辑运算符：&& || !

• 位运算符： & | ^ ~ >> << >>>

• 条件运算符：? :

• 扩展赋值运算符： += -= *= /=

====================================================================

4.1.2位运算符

/*
A = 1010 0011
B = 0111 1110
==========================================================================
A&B = 0010 0010   与    都为真则为真
A|B = 1111 1111   或    有一个为真则为真
A^B = 1101 1101   异或  一个为真一个为假则为真，否则都为假
~B = 1000 0001    取反  结果为真则为假
*/

4.1.3三元运算符

public class Test{
      public static void main(String [] args){
            //X ? Y : Z
            //如果X==true,则结果为Y，否则结果为Z。
            int score = 50;
            String type = score  < 60 ?"不及格" : "及格";  
            int score2 = 80;
            String type2 = score < 60 ?"不及格" : "及格"; 
            System.out.println(type);      //不及格
            System.out.println(type2);    //及格
      }
}

4.1.4字符串连接符 “ + ”

public class Test{   
      public static void main(String [] args){      
            int a = 1;      
            int b = 2;      
            System.out.println("" + a + b);  //12 
            System.out.println(a + b + "");  //3   
            //如果字符串在后面，前面依旧会进行运算         
      }
}    

5.1包机制

• 为了更好的组织类，Java提供了包机制，用于区别类名的命名空间。
• 包名(package)必须在整个类的最上边。

• 包机制的语法格式为：

package pkg1[.pkg2[.pkg3……]];

• 一般使用公司域名倒置作为包名

如： 域名是：www.xxx.com

      包名就是：com.xxx.www

• 使用某一个包的成员，我们需要在Java程序中明确导入该包。使用"import"语句即可。

import package1[.pakage2……].(classname|*);

JavaSE_基础语法

标签：break   单元   结束   for   transient   constant   Java变量   display   byte   

原文地址：https://www.cnblogs.com/jeter/p/14727946.html