Javaの基础语法

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

1.注释

定义：

在代码量较多或者项目结构较复杂时，需要对代码进行注释，以便于以后或他人能看懂写的代码的含义
注释并不会被执行，是给写代码的人看的
书写注释是一个非常好的习惯
平时写代码一定要注意规范
分类：
- 单行注释
- 多行注释
- 文档注释
示例和详解：

public class 注释 {
    public static void main(String[] args) {

        //单行注释：只能注释一行文字。用双斜杠"//“表示，例如：
        //输出一个Hello,World!

        System.out.println("Hello,World!");

        //多行注释：可以注释一段文字。用"/*"开头、”*/“结尾，例如：
        /*
        这是一段 多行注释 の示例
        这是一段 多行注释 の示例
        这是一段 多行注释 の示例
        */

        //JavaDoc:文档注释(有一定功能，只需要做了解)：用"/**"开头、"*/"结尾，
        //且每行开头都需要加一个*号，例如：
        /**
         * @Description HelloWorld
         * @Author 低密度脂蛋白 :)
         */

    }
}

2.标识符

关键字

Java 所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符
标识符的注意点
所有的标识符都只能以字母（A-Z/a-z）、美元符（＄）、或者下划线（_）开头；首字符之后除以上字符外还可以是数字
不能使用关键字作为变量名/方法名
标识符是大小写敏感*的
可以使用中文命名，但不建议这样做、也不建议用拼音

二.数据类型

Java 是强类型语言。变量的使用要严格符合规范，所有变量都必须先定义后才能使用

1. Java 数据类型的分类

基本类型(primitive type)

1.数值类型：
- 整数类型：byte、short、int、long，分别占1、2、4、8字节范围
- 浮点类型（小数）：float、double，分别占4、8个字节
- 字符类型（一个文字）：char 占2个字节
2.boolean类型：占1位，其值只有true和false两个

  public class 数据类型 {
      public static void main(String[] args) {
  
          //整数类型：
          byte num1 = 10;//范围：-128~127（1个字节）
          short num2 = 10000;//范围：-32768~32767（2个字节）
          int num3 = 1000000000;//(最常用，正负21亿)范围：-2147483648~2147483647（4个字节）
          long num4 = 100000000000L;//范围：-9223372036854775808~92233720368547758087（8个字节）
          //注意：用long类型时，要在数字后面加一个L
  
          //浮点类型（小数/浮点数）：
          float num5 = 10.1F;//范围：（4个字节）
          double num6 = 3.1415926535897932384626433832795028;//范围：（8个字节）
          //注意：用float类型时，要在数字后面加一个F
  
          //字符类型：
          char name = '低';//只能写一个单字，包括但不限于中文或字母
          //字符串：(不是关键字，是类)
          String name1 = "低密度脂蛋白:)";
  
          //布尔值
          boolean flag = true;
          boolean flag1 = false;
  
      }
  }

引用类型(reference type)

1.分为类、接口、数组（除了基本类型之外，都是引用类型）

2.数据类型扩展

public class 数据类型扩展 {
    public static void main(String[] args) {

        //整数扩展：
        //·进制问题  二进制0b  十进制  八进制0  十六进制0x(十六进制分表示为0~9 A~F)

        int i1 = 10;//十进制
        int i2 = 010;//八进制
        int i3 = 0x10;//十六进制

        System.out.println(i1);//输出10
        System.out.println(i2);//输出8
        System.out.println(i3);//输出16

        System.out.println("=================================");

        //浮点数拓展：
        //·有关于float和double无法正常对比两个数值的问题

        float i4 = 0.1F;
        double i5 = 1.0/10;//i4、i5都等于0.1
        System.out.println(i4);//输出0.1
        System.out.println(i4);//输出0.1
        System.out.println(i4==i5);//输出false(不相等)

        float i6 = 123123123F;
        float i7 = i6 + 1;//i6、i7明显不相等
        System.out.println(i6);//输出1.2312312E8
        System.out.println(i7);//输出1.2312312E8
        System.out.println(i6==i7);//输出true(相等)

        //由此可见，float和double无法正常对比两个数值
        //这是由于float和double有“有限 离散 舍入误差 大约 接近但不等于 ”这些特性导致的
        //故：最好完全避免使用浮点数进行比较
        //但：银行业务应该怎么正确表示(有关于钱)？答案是:可以使用 数学工具类：BigDecimal 进行比较

        System.out.println("=================================");

        //字符拓展：
        char i8 = 'A';
        char i9 = '低';

        System.out.println(i8);//输出 A
        System.out.println((int)i8);//强制转换 输出 65
        System.out.println(i9);//输出 低
        System.out.println((int)i9);//强制转换 输出 20302

        //所有的字符 本质上还是数字
        //Unicode编码 占用2个字节 至少可以表示65536个字符
        //编码表：类似于65代表 A、20302代表 低
        //Unicode编码从U0000~UFFFF 也可以反向输出 例：

        char i10 = '\u0041';
        System.out.println(i10);//输出 A (反向转换需十六进制，65的十六进制为41)

        System.out.println("=================================");

        //转义字符拓展：
        //· \t (制表符 类似于空格)
        //· \n (换行 也就是回车)
        //· 等等...

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

        System.out.println("=================================");

        //一些了解：
        String i11 = new String("Hello,World!");
        String i12 = new String("Hello,World!");
        System.out.println(i11==i12);//输出 false (不相同)

        String i13 = "Hello,World!";
        String i14 = "Hello,World!";
        System.out.println(i13==i14);//输出 true (相同)

        //以后学习到面向对象的时候，可以从内存分析，为什么前者 不相同

        System.out.println("=================================");

        //布尔值拓展：
        boolean flag = true;
        if (flag==true){}//菜鸟
        if (flag){}//大佬
        //上面两者 效果是相同的
        //Less is More! (代码要精简易读）

    }
}

三.类型转换

由于Java是强类型语言，所以需要进行有些运算的时候，需要用到类型转换
转换过程应该由低到高，从低到高层级：byte,shout,char-->int-->long-->float-->double

（之所以float(32位)比long(64位)高，是因为小数的优先级大于整数。）
运算中，不同类型的数据先转化为同一类型，然后进行运算

1.强制类型转换：从低转换到高

2.自动类型转换：从低转换到高

public class 类型转换 {
    public static void main(String[] args) {

        //强制转换：
        int i1 = 128;
        byte i2 = (byte)i1;//强制转换;格式: (类型)变量名

        System.out.println(i1);//输出 128
        System.out.println(i2);//输出 -128

        //这是由于byte最打支持到+127，强制转换128，导致了内存溢出*，输出错误结果

        System.out.println("==============================");

        //自动转换：
        int i3 = 128;
        double i4 = i3;

        System.out.println(i3);//输出 128
        System.out.println(i4);//输出 128.0 (因为double是小数类型，所以输出了.0)

        //由低转到高，不需要加任何东西就可以自动转换

        System.out.println("==============================");

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

        System.out.println((int)10.1);//输出 10
        System.out.println((int)-10.11F);//输出 -10
        //这就是精度出现问题的情况

        System.out.println("==============================");

        //关于字符转换的拓展：
        char i5 = 'A';
        int i6 = i5+1;

        System.out.println(i6);//输出 66 (字符A自动转换为了65，+1后输出66)
        System.out.println((char)i6);//输出 B (因为A后面就是B)

        System.out.println("==============================");

        //操作比较大数值的数时，要注意内存溢出问题
        int money = 10_0000_0000;//PS：数字之间可以用下划线分割，不会被输出
        int years = 20;
        //会出错的情况：
        int total1 = money*years;
        long total2 = money*years;
        //正确操作：
        long total3 = ((long)money)*years;

        System.out.println(total1);//输出 -1474836480 (计算时溢出了，导致结果错误)
        System.out.println(total2);//输出 -1474836480 (先输出了错误结果再转换，转换前已经存在问题)
        //正确操作的输出：
        System.out.println(total3);//输出 20000000000 (在计算完成前转换为long，输出结果正确)

        //扩展：long类型 后面加的L最好为大写，因为小写的l在代码里看起来会像数字1

    }
}

四.变量、常量、作用域

1.变量

变量的定义：可以变化的量
Java是一种强类型语言，每个变量都必须声明其类型
Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型，和作用域

格式：数据类型 变量名 = 值；
type varName [=value][{,varName[=value]}];
（可以使用逗号隔开来声明多个同类型变量，但不建议在一行里定义多个值）

举一些变量的例子：

//举一些变量的例子：

//int a=1,b=2,c=3;不建议这样一行定义多个值
//建议下面这样写：
int a = 1;
int b = 2;
int c = 3;
String name = "低密度脂蛋白";
char A = 'A';
double pi = 3.1415926;

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

2.变量作用域

分类
- 类变量
- 实例变量
- 局部变量

  public class 变量 {
  
      //实例变量**  示例：
      String name;
      int age;
  
      //类变量***  示例：
      static double salary = 2500;
  
      public static void main(String[] args) {
           //一些有关的 基础知识
          /*
           * 最外面 public class{} 代表类
           * public static void main(String[] args) {} 代表main方法
           * 方法在类里面。除了方法，类里面还可以定义一些 属性(暂时理解为变量)
           * 除了main方法还可以写 其他方法，例如下面大括号下的add方法*
           */
  
          System.out.println("==============================");
  
          //局部变量：两个大括号之间的变量，{生命周期在两个大括号之间}
          //使用之前必须声明和初始化值
          //举例：
          int i = 10 ;
          System.out.println(i);//此大括号内可以输出10，大括号外无法输出i
  
          System.out.println("==============================");
  
          //实例变量：从属 域对象(位置在类里面 方法外面) 位置**
          //比较高级，可以直接使用，不用初始化
          /*如果不初始化，这个类的默认值 0或0.0;布尔值默认是false;
          除了基本类型，其余的默认都是null*/
          //示例：
  
          变量 变量 = new 变量();
          System.out.println(变量.age);//没有初始化，输出默认值0
          System.out.println(变量.name);//没有初始化，非基本类型，输出默认值null
  
          System.out.println("==============================");
  
          //类变量：从属于类(和实例变量位置相同***)，区别是前面要加 static
          //示例：
  
          System.out.println(salary);//输出2500.0
  
      }
      //*其他方法：
      public void add(){}
  }

3.常量

**常量（Constant）的定义：初始化后不能再改变值，不会变动的值
可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变

格式：final (这是常量名)=值；
final double PI = 3.14;

常量名一般使用大写字符

public class 常量 {
    
    static final double PI1 =3.14;
    final static double PI2 =3.14;
    /*static、final都是修饰符，不存在先后顺序
    所以上面两种写法都可以*/

    public static void main(String[] args) {
        System.out.println(PI1);
        System.out.println(PI2);
    }
}

4.变量的命名规范(拓展)

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

五.运算符

Java语言支持如下运算符：

重点掌握前四个

算数运算符：+，-，*，/，%（模，也就是取余，余数），++，--
赋值运算符：=
关系运算符：>，<，>=，<=，==（等于），!=（不等于），instanceof
逻辑运算符：&&，||，!（与，或，非）
位运算符：&，|，^，~，>>，<<，>>>，（了解就可以）
条件运算符：？：
扩展赋值运算符：+=，-=，*=，/=

package base;

public class 运算符operator {
    public static void main(String[] args) {
        //二元运算符
        /*扩展 ctrl + D :复制当前行到下一行*/
        int a = 10;
        int b = 20;

        System.out.println(a + b);//输出 30 √
        System.out.println(a - b);//输出 -10 √
        System.out.println(a * b);//输出 200 √
        System.out.println(a / b);//输出 0 ×
        /*因为int是整数类型，这里只保留了0.5的整数部分，所以为0
         *正确操作应该是强转为小数类型 double 如下 */
        System.out.println((double) a / b);//输出正确答案 0.5

        System.out.println("==============================");

        //不同类型的数运算
        long c = 123123123123L;
        int d = 123;
        short e = 12;
        byte f = 1;

        System.out.println(c + d + e + f);//输出 123123123259 为long类型
        System.out.println(d + e + f);//输出 136为int类型
        System.out.println(e + f);//输出 13 为int类型
        /*在整数计算中，如果有一个数为long类型，则会输出的结果也为long类型
        * 没有long类型参与计算的时候，结果都为int类型
        * 同理，如果有一个数为double类型，也会输出double类型的结果*/

        System.out.println("==============================");

        //% 模运算  也就是取余计算
        int g = 21;
        int h = 10;

        System.out.println(g%h);//输出 1 也就是21除以10 等于2余1



        System.out.println("==============================");

        //关系运算符 返回的结果： 正确，错误 (布尔值)

        int i = 1;
        int j = 2;

        System.out.println(i>j);//输出 false
        System.out.println(i<j);//输出 true
        System.out.println(i==j);//输出 false
        System.out.println(i!=j);//输出 true

    }
}

自增自减运算符初识Math类

package base;

public class 自增自减运算符 {
    public static void main(String[] args) {
        //++ --  自增，自减  一元运算符
        //x++或++x 的意思就是 x+1 (自增) x--亦然

        int a = 3;

        int b = a++;//执行完这行代码后，先给b赋值，a再自增
        //也就是此时 b=3，a=4

        System.out.println(b);//输出 3
        System.out.println(a);//输出 4

        System.out.println("==============================");

        int c = ++a;//执行完这行代码前，a先自增，再给b赋值
        //也就是此时 a=5(4+1) c=5

        System.out.println(a);//输出 5
        System.out.println(c);//输出 5

        System.out.println("==============================");

        /* 扩展：幂运算 日常 2^3=2*2*2 = 8 但Java不这样写
         * 很多计算我们会使用一些工具类来操作*/

        double d = Math.pow(2, 3);
        //Math类提供了很多科学工程类计算需要的方法和常数，Math.pow为幂运算

        System.out.println(d);//输出 8.0 (2的3次方)

    }
}

逻辑运算符、位运算符

package base;

public class 逻辑运算符_位运算符 {
    public static void main(String[] args) {
        //逻辑运算符  (与：and，或：or，非：取反)
        boolean a = true;
        boolean b = false;

        System.out.println("a && b：" + (a && b));//输出 false
        // 逻辑与运算：两个变量都为真，结果才为true
        System.out.println("a || b:" + (a || b));//输出 true
        // 逻辑或运算：两个变量有一个真，结果则就为true
        System.out.println("！（a && b）:" + !(a && b));//输出 true
        // 逻辑非操作：如果是真，则为假、如果是假，则为真
        //且有括号才能先运算括号内的内容

        System.out.println("==============================");

        //短路运算
        int c = 5;
        boolean d = (c < 4) && (c++ < 6 );

        System.out.println(d);//输出 false
        System.out.println(c);//输出 5
        /*这里因为是与运算，一个假则输出假，由于前面c<4为假，就已经可以得出false了，
        * 这里就短路了，根本没有继续执行c++是否<6这一步，故输出的c也没有自增为6 */

        System.out.println("==============================");

        //位运算符

        /*
        A = 0011 1100
        B = 0000 1101

        A&B = 0000 1100 (竖向统计，都为1才为1，否则为0)
        A|B = 0011 1101 (竖向统计，有一个为1就为1，都为0则为0)
        A^B = 0011 0001 (竖向比较，相同为0,不同为1)
        ~B = 1111 0010 (B的0和1完全取反)

        位运算拓展：  <<(左移) 、 >>(右移)
        关于如何最快运算2*8 =16  (2*2*2*2)
         */

        System.out.println(2<<3);//输出 16
        //二进制里左移三位的意思

        /* 原理：
        左移相当于*2  右移相当于/2
        **效率极高**
        0000 0000    0
        0000 0001    1
        0000 0010    2
        0000 0011    3
        0000 0100    4
        ...
        0000 1000    8
        0001 0000    16
         */
    }
}

三元运算及小结

package base;

public class 三元运算符及小结 {
    public static void main(String[] args) {
       int a = 10;
       int b = 20;

       a+= b;//a = a+b 也就是10+20
        System.out.println(a);//输出 30，此时a为30

       a-= b;//a = a-b 也就是30-20
        System.out.println(a);//输出 10，此时a为10

        System.out.println("==============================");

        //拓展：字符串连接符  +

        System.out.println(a+b);//输出 30，正常的相加
        System.out.println(""+a+b);//输出 1020
        System.out.println(a+b+"");//输出 30
        /*原理：
        在+号两侧，只要有一边出现了string(字符串)类型，
        则会把其他操作数都转换为string类型然后进行连接，
        但是若string类型出现在末尾，前面也会先进行运算
         */

        System.out.println("==============================");

        //三元运算符  ? 、 :
        /*
        x ? y : z
        意思是如果x==ture，则结果为y，否则结果为z
         */
        //示例：  (以下操作很常见，必须掌握)
        int score1 = 80;
        int score2 = 50;

        String type1 = score1 >60 ? "及格":"不及格";
        String type2 = score2 >60 ? "及格":"不及格";

        System.out.println(type1);
        System.out.println(type2);

        System.out.println("==============================");

        //拓展：有关于 优先级， 可以多使用括号表示优先
        int c = 2;
        int d = 10;
        int e = 20;

        System.out.println((d+e)/c);//输出 15 ，括号优先
        System.out.println(d+e/c);//输出 20 ，除法优先

    }
}

六.包机制、JavaDoc

包机制

为了更好的组织类，Java提供了包机制，用于区别类名的命名空间（相当于可以在不同文件夹内放相同名字的文件），包的本质就是文件夹
包语句的语法格式为：

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

类都是以此开头，package必须写在整个类的最上面，package 后面为类的路径
一般用公司域名倒置作为包名 举例：com.baidu.www
为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用"import"语句可以完成此功能

import package1[.package2...].(classname|*)

导入包的语句也是必须在package语句的后面，示例：

package Java基础语法;

import java.util.Date;

//导入一个包下所有的类：可以使用通配符.*，将导入这个包下所有的类

import Java基础语法.*;

JavaDoc

Javadoc命令是用来生成自己API文档的
参数信息
- @author 作者名
- @version 版本号
- @since 指明需要最早使用的jdk版本
- @param 参数名
- @return 返回值情况
- @throws 异常抛出情况

package Java基础语法;

/**
 * @author 低密度脂蛋白
 * @version 1.0
 * @since 1.8
 */

public class JavaDoc {

    String name;

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

加在类上面就是类的注解，加在方法的上面就是方法的注解
1.通过命令行生成Java文档：在Java类所在目录前输入cmd，

然后在命令行输入 javadoc 参数 Java文件，例如：javadoc -encoding UTF-8 -charset UFT-8 JavaDoc.java

会生成包括首页index.html在内的很多文件（现在还不知道干嘛用的）
2.通过IDEA生成Java文档：在IDEA中打开相应的Java文件，点击顶部的工具--生成JavaDoc(D)，选择或输入相应参数，点击确定即可将javadoc生成到指定目录

基础部分的一切知识，后面几乎每天都会用到，需要认真吸收并牢牢掌握。

end.

posted @ 2021-03-03 17:21 低密度脂蛋白阅读(69) 评论(0) 收藏举报

刷新页面返回顶部

低密度脂蛋白

欢迎来到我的博客

Javaの基础语法

Javaの基础语法

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

1.注释

定义：

分类：

示例和详解：

2.标识符

关键字

标识符的注意点

二.数据类型

1. Java 数据类型的分类

2.数据类型扩展

三.类型转换

1.强制类型转换：从低转换到高

2.自动类型转换：从低转换到高

四.变量、常量、作用域

1.变量

2.变量作用域

3.常量

4.变量的命名规范(拓展)

五.运算符

Java语言支持如下运算符：

自增自减运算符初识Math类

逻辑运算符、位运算符

三元运算及小结

六.包机制、JavaDoc

包机制

JavaDoc

基础部分的一切知识，后面几乎每天都会用到，需要认真吸收并牢牢掌握。

公告

低密度脂蛋白

欢迎来到我的博客

Javaの基础语法

Javaの基础语法

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

1.注释

定义：

分类：

示例和详解：

2.标识符

关键字

标识符的注意点

二.数据类型

1. Java 数据类型的分类

2.数据类型扩展

三.类型转换

1.强制类型转换：从低转换到高

2.自动类型转换：从低转换到高

四.变量、常量、作用域

1.变量

2.变量作用域

3.常量

4.变量的命名规范(拓展)

五.运算符

Java语言支持如下运算符：

自增自减运算符 初识Math类

逻辑运算符、位运算符

三元运算及小结

六.包机制、JavaDoc

包机制

JavaDoc

基础部分的一切知识，后面几乎每天都会用到，需要认真吸收并牢牢掌握。

公告

自增自减运算符初识Math类