快速掌握JAVA基础数据类型-综合_java

1. 注释、标识符、关键字

2. 数据类型

3. 类型转换

4.变量和常量

5. 运算符

6. 包机制、JavaDoc

1.1 注释（扫一眼就行）

注释本质上就是对代码的解释说明，很多代码，尤其是当年项目结构变得很复杂的时候，对代码做适当的标注，记录，有助于查阅代码，尤其是时间一长我们连自己写的代码都看不懂了（坑啊），这个时候注释就显得那么重要。当然也是为了代码规范性以及可维护性考虑。

所以看见书写注释是一件多么重要且好的习惯

Java中注释有三种：分别为单行注释，多行注释，文档注释。

示例：

public class Demon1 {
    public static void main(String[] args) {
        // 单行注释
        String name = "小明";
        int age = 30;
        /*  多行注释
        随便写，
        跟着狂神学习SE系列*/
        System.out.println(age);
    }
}

除此之外，查阅其他博客发现也有很多有趣的代码注释等，例如

/*
 * ░░░░░░░░░░░░░░░░░░░░░░░░▄░░
 * ░░░░░░░░░▐█░░░░░░░░░░░▄▀▒▌░
 * ░░░░░░░░▐▀▒█░░░░░░░░▄▀▒▒▒▐
 * ░░░░░░░▐▄▀▒▒▀▀▀▀▄▄▄▀▒▒▒▒▒▐
 * ░░░░░▄▄▀▒░▒▒▒▒▒▒▒▒▒█▒▒▄█▒▐
 * ░░░▄▀▒▒▒░░░▒▒▒░░░▒▒▒▀██▀▒▌
 * ░░▐▒▒▒▄▄▒▒▒▒░░░▒▒▒▒▒▒▒▀▄▒▒
 * ░░▌░░▌█▀▒▒▒▒▒▄▀█▄▒▒▒▒▒▒▒█▒▐
 * ░▐░░░▒▒▒▒▒▒▒▒▌██▀▒▒░░░▒▒▒▀▄
 * ░▌░▒▄██▄▒▒▒▒▒▒▒▒▒░░░░░░▒▒▒▒
 * ▀▒▀▐▄█▄█▌▄░▀▒▒░░░░░░░░░░▒▒▒
 * 单身狗。
 */

1.2 标识符 1.2.1 关键字

Java所有组成部分都需要名字。类名，变量名以及方法名都被称为标识符，当然标识符的命名是不能和关键字重复的，这个无可厚非，golang等很多语言也是如此。

Java关键字如下表所示，

abstract	assert	boolean	break	byte
case	catch	char	class	const
continue	default	do	double	else
enum	extends	final	finally	float
for	goto	if	implements	import
instance of	int	interface	long	native
new	package	private	protected	public
return	strictfp	short	static	super
swtich	synchronized	this	throw	throws
transient	try	void	volatitle	while

1.2.2 标识符需要注意点什么

所有的标识符首字符必须是字母（A-Z或a-z），$,或者下划线_
首字符之后可以是字母，$,下划线以及数字的任意字符组合。
不能使用关键字作为变量名或者方法名
标识符对于大小写是敏感的。

2.1 数据类型 2.1.1 基本数据类型

强类型语言：

要求变量的使用要严格且要符合规定，所有变量都必须先定义后才能使用，即一旦变量类型被定义，除非强制转换，否则不会改变其数据类型，强类型语言包括Java、.net 、Python、C++等语言。

弱类型语言：例如vb 、PHP、javascript等语言。

比较：强类型语言因为其使用严格，安全性较高，这里的安全性多指由于严谨性从而避免产生不必要的错误。

Java数据类型分类如下图所示：

代码示例：

public class Demon2 {
    public static void main(String[] args) {
        //八大基本数据类型
        int num1 = 10;
        byte num2 = 20;
        short num3 = 30;
        long num4 = 30L; //long类型要在数字后面加L
        //浮点数
        float num5 = 50.1F; //float类型要在数字后面加个F
        double num6 = 3.141592673892939378472;
        //字符 注：char只能放单个字符 单引号
        //字符：字母，数字，字和符号
        char name = '王';
        //字符串String不是关键字，是类
        String name1 = "kuangshen";
        //布尔值
        boolean flag = true;
        //boolean flag = false;
    }
}

数据类型注意不要越界的问题即可。

2.1.2 数据类型扩展

整数类型扩展：进制，二进制，八进制，十六进制

public class Demon3 {
    public static void main(String[] args) {
        //整数拓展 进制：二进制0b，十进制，八进制0，十六进制0x
        int  num1 = 10;
        int  num2 = 010;  //8进制
        int  num3 = 0x10; //16进制
        System.out.println(num1);  //10
        System.out.println(num2);   //8
        System.out.println(num3); //16
    }
}

浮点数扩展：

如下所述：

float 类型有限有误差接近但是不等于，所以f=d是false

***最好不要使用浮点数来进行比较，容易出现问题，使用java bigDecimal类。

public class Demon3 {
    public static void main(String[] args) {
        //整数拓展 进制：二进制0b，十进制，八进制0，十六进制0x
        int num1 = 10;
        int num2 = 010;  //8进制
        int num3 = 0x10; //16进制
        System.out.println(num1);  //10
        System.out.println(num2);   //8
        System.out.println(num3); //16
        System.out.println("=========================================");
        // 浮点数扩展  
        // float 有限  接近但是不等于
        float f = 0.1f;
        double d = 1.0 / 10;
        System.out.println(f == d);  //false
        System.out.println(f);
        System.out.println(d);

        float d1 = 123904905901f;
        float d2 = d1 + 1;
        System.out.println(d1 == d2);  //true
        System.out.println("=========================================");
        //字符扩展
        //所有字符本质还是数字 unicode编码
        char c1 = 'a';
        char c2 = '强';
        System.out.println(c1); //a
        System.out.println((int) c1); //97
        System.out.println(c2); //强
        System.out.println((int) c2); //24378
        char c3 = '\u0061';
        System.out.println(c3); //a
        //转义字符
        // \t制表符  \n 换行 
        //boolean 扩展
        boolean flag = true;
        if (flag == true) {
        }
        if (flag) {
        }


    }}

2.1.3类型转换

当数据从大转换到小，需要使用到强制类型转换。也就是说使用强制类型转换的关键点在于数据类型大范围------>数据类型小范围，例如int型----->byte型需要强制类型转换。

由于java是强类型语言，所以进行部分运算时，需要用到强制转换。

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

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

注：运算中，不同类型的数据必须先转成同一类型，然后在进行相应运算。

ps: 什么时候需要用到强制类型转换？，什么时候需要用到自动类型转换？

示例：

package Base;

public class Demon6 {
    public static void main(String[] args) {
        int a = 128;
        byte b = (byte) a;
        //强制转换格式  (类型)变量名     高--->低    这个和python区别还挺大 哈哈
        //自动转换  低---->高
        System.out.println(a); //128
        System.out.println(b); //-128
        /*
        内存溢出  造成上面的问题，也就就数据范围由大到小转换的时候，可能会存在内存溢出的问题
        注意点：
            1：不能对布尔值进行转换
            2: 不能吧对象类型转换为不相干的类型
            3：高范围---->低范围转换  需要强制转换
            4：转换的时候可能会存在内存溢出问题，或者是精度问题。
         */
    }
}

package Base;

public class Demon7 {
    public static void main(String[] args) {
        double a = 27.3;
        float b = -45.98f;
        System.out.println((int)27.3); //27  高-低  自动转
        System.out.println((int)-45.98f);//-45 精度丢失
        System.out.println("============================");
        char c = 'a';
        int d = c + 1;
        System.out.println(d);  //98
        System.out.println((char) d); //b
    }
}

package Base;

public class Demon8 {
    public static void main(String[] args) {
        // *** 作比较大的数的时候，注意溢出问题
        //JDK7新特性，数字之间可以用下划线分割
        int money = 10_000_00000;
        int year = 20;
        int total = money * year;  
        System.out.println(total); // -1474836480  计算的时候溢出了
    }
}

3.1 变量和常量 3.1.1 变量

Java是一种强类型语言，每个变量都必须声明其类型

Java变量是程序中最基本的存储单元，其中包含变量名+变量类型+作用域

type varName1 = value1
type varName2 = value2
type varName3 = value3,value4,
//数据类型 变量名 = 值 来声明一个变量
//可以使用逗号隔开来声明多个同类型变量

注意：

每个变量均是有类型的，类型要么是基本类型，要么就是引用类型
变量名必须是合法的标识符
变量的声明是一条完整的语句，声明必须以分号；结尾。

public class Demon4 {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        int c = 3;
        String name = "西安";
        char x = 'x';
        double p1 = 3.14;
    }
}

变量的命名规范：

所有变量，方法，类名命名符合开发要求，即：见名知意
类成员变量：首字母小写和驼峰原则：mouthSalary
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线 PI MAX_VALUE
类名：首字母大写和驼峰原则：Man BadBoy
方法名：首字母小写和驼峰原则 run(), runRun()

3.1.2 常量 (Constant)

初始化后，值无法改变，也就是值被设定之后，在程序运行过程中不允许改变

final double PI = 3.14 //final 常量名=值;

常量名一般使用大写字符。

示例；

public class Demon7 {
    // 修饰符不存在先后顺序
    final static double PI = 3.14;
//    static final double PI = 3.14;
    public static void main(String[] args) {
        System.out.println(PI);
    }
}

3.1.3 作用域

类变量

实例变量

局部变量

public class Demon5 {
   static int allclicks = 0;  //类变量
   String str = "hello world"; //实例变量
   public void method(){
       int i = 0; //局部变量
   }
}

public class Demon6 {
   /*
   除了基本数据类型，其余默认值都是null;
   boolean默认值是flase
    */
    static double salary = 2500;
    String name; //属性；变量
    int age;  //实例变量，从属于对象；如果不自行初始化，这个类型的默认值0  0.0
    //main方法
    public static void main(String[] args) {
        int i = 10;//局部变量：必须声明和初始化值
        System.out.println(i);
        //变量类型  变量名 = new Demon6();
        Demon6 demon6 = new Demon6();
        System.out.println(demon6.age);  //  默认值
        System.out.println(demon6.name);  //null  默认值
    }
    //其他方法
    public void add(){

    }
}

4.1 运算符

4.1.1 基本运算符

package Operator;

public class Demon2 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a>b); // 关系运算符返回的结果，只有true或者false
        System.out.println(a%b);  // 10
//        System.out.println(a+b); //30
//        System.out.println(a-b); //-10
//        System.out.println(a*b); //200
//        System.out.println(a/(b)); // 0  精度丢失
//        System.out.println(a/(double)b); // 0.5

//        long a = 123456000000000789L;
//        int b = 123;
//        short c = 10;
//        byte d = 8;
//        System.out.println(a+b+c+d); //  long
//        System.out.println(b+c+d); //141 int
//        System.out.println(c+d); //18 int
    }
}

4.1.2 自增自减，Math类

package Operator;

public class Demon4 {
    public static void main(String[] args) {
        // 一元运算符 ++ --
        int a = 3;
        int b = a++;
        //执行完这行代码后，先给b赋值，在自增
        System.out.println(a); //4
        int c = ++a; //执行完这行代码后，先自增，再给b赋值
        System.out.println(a);  //5
        System.out.println(b); //3
        System.out.println(c); //5

        //幂运算 2^3  java自带数学类  
        double pow1 = Math.pow(2,3);  
        System.out.println(pow1);
        //很多运算，我们通常会使用一些工具类来 *** 作
    }
}

4.1.3 逻辑运算符，位运算符

与或非

>> <<

补充：字符串拼接

  System.out.println("---"+a);  //---false

注:实际上计算机不会有加减等 *** 作，底层在做加乘除是利用位运算以及逻辑运算。

4.1.4 三元运算法+小结

本质就是在做简化没别的含义

package Operator;

public class Demon7 {
    public static void main(String[] args) {
        // 格式; x ? y : z
        //  如果x为真，那么结果就是y,否则就是z
        int score = 80;
        String root = score < 60 ? "不及格" : "及格";
        System.out.println(root);
    }
}

5.1 包机制+JavaDoc 5.1.1 包机制

为了更好的组织类，JAVA提供了包机制，用于区别类名的命名空间
包语句的语法格式为
```
Package pkg1
```
一般利用公司域名倒置作为包名
import com.compancy.wenku（举例）com.zhang.www
为了能够使用某一个包的成员，需要在JAVA程序中明确导入该包，使用“import”语句可以完成此功能。
import package1 *
```
z
```
```
import java.util.Scanner;
```

5.1.2 JavaDoc （注释中的文档注释）

JavaDoc:将注释生成HTML文档,本质就是将代码类的关系等结构以文档的形式展示，使其一目了然.

百度搜索JAVA帮助文档

帮助文档

API文档

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

参数信息：

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

package Base;
//  /**回车
/**
 * @author kuangshen
 * @version 1.0
 * @since 1.8
 */
public class doc {
    String name;

    /**
     * 
     * @param name
     * @return
     */
    public String test(String name){
        return name;
    }
}

加在类上面就是就是类的注释，加在方法上就是方法的注释，方法上/**回车会自动写好

1:命令行生成javadoc

javadoc -encoding UTF-8 -charset UTF-8 Doc.java

IDEA生成javadoc API文档

tools 选择generate javadoc

说明：上述学习记录来源于狂神JAVASEkuangshen

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/795157.html

快速掌握JAVA基础数据类型-综合

发表评论

评论列表（0条）