Java基础：第一章、基础语法

2021-04-09 07:26

阅读：426

标签：允许一个 load 类成员否则开始 tool 字符扩展 rgs

第一章、基础语法

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

注释

平时我们编写代码，当代码量还比较少的时候，我们会很容易读懂我们写的代码，但是当项目结构一旦复杂起来，读起来就不那么容易了，这时就需要一个类似笔记的东西，让我一看到这个提示，就能很清晰的知道我写的这块代码是什么功能，这就是注释的作用；
注释不会参与程序的执行，仅仅是给我们写代码的人看；
书写注释是一个非常好的习惯
平时写代码一定要注意规范！

1、Java中的注释有三种：

单行注释：注释一行文字
多行注释：注释一段文字
文档注释

标识符

1、关键词

技术图片

2、标识符注意点

所有的标识符都应该以字母（A-Z或者a-z），美元符（$）或者下划线（__）开始
首字符之后可以是字母（A-Z或者a-z），美元符（$），下划线（__）或数字的任何字符组合
不能使用关键字作为变量名或方法名
标识符是大小写敏感的
合法标识符举例：age、$salary、_value、__1_value
非法标识符举例：123age、-salary、#age
可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼音

2、数据类型

1、强类型语言

要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用

2、弱类型语言

比如VB和JavaScript，变量的使用很随意

3、Java的数据类型分为两大类

基本类型（primitive type）
引用类型（reference type）

4、什么是字节？

位（bit）：是计算机内容数据储存的最小单位，11001100是一个八位二进制数
字节（byte）是计算机中数据处理的基本单位，习惯上用大写B表示
1B（byte，字节）=8bit（位）
字符：是指计算机中使用的字母、数字、字和符号
1bit表示1位
1Byte表示一个字节1B=8bit
1024B = 1KB
1024KB = 1M
1024M = 1G
1024G = 1T

5、数据类型面试题讲解

/*
 *
 *@author  Jack
 *@create 2020.07.21 下午 8:18
 */
public class Demo03{
    public static void main(String[] args){
        //整数拓展    进制    二进制0b     十进制  八进制0   十六进制0x
        int i1 = 10;//十进制
        int i2 = 010;//八进制
        int i3 = 0x10;//十六进制

        System.out.println(i1);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println("========================================");

        //========================================
        //浮点数扩展?  银行业务怎么表示？钱
        //BigDecimal    数学工具类
        //========================================
        //float   有限的  离散的  舍入误差   结果是个约束  接近但不等于
        //double
        //最好完全避免使用浮点数进行比较
        //最好完全避免使用浮点数进行比较
        //最好完全避免使用浮点数进行比较

        float f = 0.1f;//0.1
        double d = 1.0/10;//0.1
        System.out.println(f==d);//false
        
        float d1 = 223632325f;
        float d2 = d1+1;
        System.out.println(d1==d2);//true
        System.out.println("========================================");

        //========================================
        //字符扩展?
        //========================================
        char c1 = ‘a‘;
        char c2 = ‘中‘;

        System.out.println(c1);
        System.out.println((int)c1);//强制转换

        System.out.println(c2);
        System.out.println((int)c2);

        //所有的字符本质还是数字
        //编码  Unicode 表：(97 = a  65 = A) 2字节  65536  Excel 2*16 = 65536
        // U0000  UFFFF

        char c3 = ‘\u0061‘;
        System.out.println(c3);

        //转义字符
        //\t = 制表符
        //\n = 换行
        //。。。

        System.out.println("Hello\tWorld");
        System.out.println("Hello\nWorld");

        System.out.println("========================================");
        String sa = new String("hello world");
        String sb = new String("hello world");
        System.out.println(sa == sb);

        String sc = "hello world";
        String sd = "hello world";
        System.out.println(sc == sd);

        //布尔值扩展
        boolean flag = true;
        if(flag==true){}//新手程序员
        if(flag){}//老司机
        //Less is More!   代码要精简易读
    }
}

3、类型转换

由于Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换
类型的优先级如下

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

byte，short，char --> int --> long --> float --> double
运算中，不同类型的数据先转化为同一类型，然后进行运算

类型转换的两种方式

强制类型转换：由高到低（注意内存溢出问题！）
自动类型转换：由低到高

/*
 *
 *@author  Jack
 *@create 2020.07.21 下午 10:43
 */
public class Demo05{
    public static void main(String[] args){
        //强制类型转换  （类型）变量名   优先级：高--->低
        int i = 128;
        byte b = (byte) i;//内存溢出
        System.out.println(i);
        System.out.println(b);

        //自动类型转换                优先级：低--->高
        double d = i;
        System.out.println(d);

        /*
          注意点：
          1.不能对布尔值进行转换
          2.不能把对象类型转换为不相干的类型
          3.在把高容量转换到低容量的时候，需要强制类型转换，反之不用
          4.转换的时候可能存在内存溢出，或者精度问题！

        */

        System.out.println("=============================");
        System.out.println((int) 23.7);//23
        System.out.println((int) -23.78f);//-23
        System.out.println("=============================");
        char a = ‘a‘;
        int g = a+1;
        System.out.println(g);
        System.out.println((char)g);

    }
}

类型转换在操作数值比较大的数时，需要注意的点：

/*
 *
 *@author  Jack
 *@create 2020.07.22 下午 8:57
 */
public class Demo06{
    public static void main(String[] args){
        //操作比较大的数的时候，注意溢出问题
        //JDK7新特性，数字之间可以用下划线做分割，但不会影响其值
        int money = 10_0000_0000;
        System.out.println(money);
        int year = 20;
        int total = money * year;//-1474836480 , 计算结果溢出了
        long total2 = money * year;//两个数相乘默认是int类型，就算你赋值给long也没用，因为在转换之前已经出问题了
        long total3 = (long) (money * year);//这里还是无法成功，因为压根没有解决相乘时的精度问题，还是两个int相乘
        long total4 = money * ((long)year);//问题得到解决！（先把一个数在计算之前转换为long）
        System.out.println(total);
        System.out.println(total2);
        System.out.println(total3);
        System.out.println(total4);

        //L 与 l  大写的L与小写的L，一定要细心。以后表示long都统一使用大写的L。因为小写的l很像数字一！
    }
}

4、变量、常量

变量

变量是什么：就是可以变化的量！是内存中的一块空间
Java是一种强类型语言，每一个变量都必须声明其类型

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

type varName [=value] [{,varName[=value]}];
//数据类型  变量名 = 值； 可以使用逗号隔开来声明多个同类型变量

注意事项：
- 每一个变量都有类型，类型可以是基本类型，也可以是引用类型
- 变量名必须是合法的标识符
- 变量声明时一条完整的语句，因此每一个声明都必须以分号结束

变量的作用域

类变量
示例变量
局部变量

/*
 *
 *@author  Jack
 *@create 2020.07.22 下午 9:29
 */
public class Demo08{

    //属性：目前理解为变量

    //实例变量：从属于对象；
    String name;
    int age;

    //类变量  static
    static double salary = 26000;


    //main方法，程序的入口
    public static void main(String[] args){

        //局部变量再次：必须声明和初始化；如果不进行初始化（赋值），那就会是默认值，如int的默认值为0！
        //0  0.0  u0000
        //布尔值的默认值是：false
        //除了基本类型，其余的默认值都是：null
        int i = 10;
        System.out.println(i);

        //使用实例变量
        Demo08 demo08 = new Demo08();
        System.out.println(demo08.age);
        System.out.println(demo08.name);

        //类变量  static
        System.out.println(salary);
    }


    //其他方法
    public void add(){

    }
}

常量

常量（Constant）：初始化（Initialize）后不能再改变值！不会变动的值！
所谓常量可以理解为一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变
```
final 常量名 = 值;
final double PI = 3.14;
```
常量名一般使用大写字符

变量的命名规范

所有变量、方法、类名：见名知意
类成员变量：首字母小写和驼峰原则：monthSalart
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则：Man，GoodMan
方法名：首字符小写和驼峰原则：run()，runRun()

5、运算符

1、Java语言支持如下运算符：

算术运算符：+，-，*，/，%，++，--

package operator;

/*
 *运算符加减乘除
 *@author  Jack
 *@create 2020.07.22 下午 10:43
 */
public class Demo01{
    public static void main(String[] args){
        //二元（双目）运算符
        //ctrl + D : 赋值当前行到下一行
        int a = 10;
        int b = 20;
        int c = 30;
        int d = 40;

        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/(double)b);

    }
}

package operator;

/*
 *
 *@author  Jack
 *@create 2020.07.22 下午 10:49
 */
public class Demo02{

    public static void main(String[] args){
        long a = 5425265254284125L;
        int b = 123;
        short c = 10;
        byte d = 8;

        System.out.println(a+b+c+d);//Long
        System.out.println(b+c+d);//Int
        System.out.println(c+d);//Int

        /*
            总结：
            如果参与运算的有long或者是double，那么结果就是long或double
            其余所有的运算结果默认都为int
        */
    }
}

赋值运算符：=

关系运算符：>，=，

package operator;



/*
 *关系运算符
 *@author  Jack
 *@create 2020.07.22 下午 10:57
 */
public class Demo03{
    public static void main(String[] args){
        //关系运算符返回的结果：  正确，错误  布尔值
        //搭配 if 使用

        int a = 10;
        int b = 200;
        int c = 22;

        //取余，也称模运算
        System.out.println(c%a);// （22 / 10 = 2 …… 2）
        System.out.println(a>b);
        System.out.println(a

package operator;

/*
 *++ --
 *@author  Jack
 *@create 2020.07.23 上午 10:47
 */
public class Demo04{
    public static void main(String[] args){
        //++ -- 一元运算符
        int a = 3;

        int b = a++;//执行完这行代码后，先给b赋值，再自增
        // a = a + 1;
        System.out.println(a);//4
        // a = a + 1;
        int c = ++a;//执行完这行代码前，先自增，在给c赋值

        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(a);
        //幂运算  2^3 = 2 * 2 * 2 = 8
        double pow = Math.pow(2, 3);
        System.out.println(pow);
        //很多的运算，我们会使用一些工具类来操作，比如，科学计算就需要用到Math类！

    }
}

逻辑运算符：&&，||，！

package operator;

/*
 *逻辑运算符
 *@author  Jack
 *@create 2020.07.23 上午 11:02
 */
public class Demo05{
    public static void main(String[] args){
        //与（and）  或（or）   非（取反）
        boolean a = true;
        boolean b = false;

        System.out.println("a && b：" + (a && b));//逻辑与运算，两个变量都为真，结果才为true
        System.out.println("a || b：" + (a || b));//逻辑或运算，两个变量有一个为真，则结果为true
        System.out.println("!(a && b)：" + (!(a && b)));//真变假，假变真

        //短路运算：如果与运算的前者为假，那么就不会执行后者，直接返回false
        System.out.println("============================");
        int c = 4;
        boolean d = (c

位运算符：&，|，^，~，>>，>>（了解即可！！！）

package operator;

import java.sql.SQLOutput;

/*
 *位运算
 *@author  Jack
 *@create 2020.07.23 上午 11:17
 */
public class Demo06{
    public static void main(String[] args){
        /*
        A = 0011 1100
        B = 0000 1101
        ---------------------------
        A & B =  0000 1100   （全1为1
        A | B =  0011 1101   （有1为1
        A ^ B =  0011 0001   （相同为0，不同为1
        ~ B = 1111 0010      （按位取反

        2*8 = 16  使用移位操作进行运算效率极高
        >右移 表示 /2

        0000 0000  0
        0000 0001  1
        0000 0010  2
        0000 0011  3
        0000 0100  4
        0000 1000  8
        0001 0000 16

        */
        System.out.println(2

条件运算符：？，：

package operator;

/*
 *三元运算符
 *@author  Jack
 *@create 2020.07.23 下午 12:28
 */
public class Demo08{
    public static void main(String[] args){
        //x ? y : z
        //如果x为true，则结果为y，否则为z
        //找到30W的工作 ? 开始好日子 : 艰苦生活

        int score = 88;
        String type = score

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

package operator;

/*
 *偷懒的运算符
 *@author  Jack
 *@create 2020.07.23 上午 11:35
 */
public class Demo07{
    public static void main(String[] args){
        int a = 10;
        int b = 20;

        a += b;//a = a+b
        a -= b;//a = a-b
        System.out.println(a);

        //字符串连接符   +   String
        System.out.println("" + a + b);//String类型在前，后面都会转化为字符串类型
        System.out.println(a + b + "");//String类型在后，前面的加减逻辑运算不变
    }
}

2、处理运算之间的优先级时，可以尽可能使用括号，让逻辑更加清晰！

6、包机制、JavaDoc

为了更好地组织类，Java提供了包机制，用于区别类名的命名空间
包语句的语法格式为：
```
package pkg1[.pkg2[.pkg3...]];
```
一般使用公司域名倒置作为包名
为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包，使用import语句可以完成此功能

JavaDoc

javadoc命令是用来生成自己API文档的
参数信息
- @author 作者名
- @version 版本号
- @since 指明使用的jdk版本
- @param 参数名
- @return 返回值情况
- @throws 异常抛出情况
在IDEA中生成JavaDoc
- 菜单栏 ----> Tools ---- > Generate JavaDoc...
- 参数说明
  1. Whole project:整个项目都生成文档
  2. Custom scope 自定义范围。如下：
    
    （1）project files 项目文件，
    
    （2）project production files 项目产品文件，
    
    （3）project test files 项目的测试文件，未知范围，class hierarchy 类层
  3. include test source 包含测试目录
  4. include JDK and … 包含jdk和其他的第三方jar
  5. link to JDK documentation…链接到JDK api
  6. output directy 生成的文档存放的位置
    
    （1）private、package、protected、public 生成文档的级别（类和方法）
    
    （2）右边的Generate…是选择生成的文档包含的内容，层级树、导航、索引..
    
    （3）再右边是生成的文档包含的内容信息，作者版本等信息
  7. Locale 语言类型,zh-CN
  8. Other command line arguments 其他参数
  9. Maximum heep… 最大堆栈
  在 “Tools->Gerenate JavaDoc” 面版的 “Other command line arguments:” 栏里输入：
```
-encoding UTF-8 -charset UTF-8 
```

Java基础：第一章、基础语法

标签：允许一个 load 类成员否则开始 tool 字符扩展 rgs

原文地址：https://www.cnblogs.com/whysff/p/13376236.html

上一篇：spring整合junit问题

下一篇：Java对象公约

文章来自：搜素材网的编程语言模块，转载请注明文章出处。
文章标题：Java基础：第一章、基础语法
文章链接：http://soscw.com/index.php/essay/73233.html

亲，登录后才可以留言！

Java基础：第一章、基础语法

第一章、基础语法

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

注释

标识符

2、数据类型

3、类型转换

4、变量、常量

变量

常量

变量的命名规范

5、运算符

6、包机制、JavaDoc

JavaDoc

评论

热门文章

推荐文章

最新文章

置顶文章