Java基础

说明：.java文件在dos窗口中运行的顺序：
首先在当前目录下运行：javac Hello.java
运行后会生成一个class文件
接着运行：java Hello
完成编译

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

1.1 注释

注释为对代码的解释，书写注释是非常好的习惯

Java中的注释有三种：

单行注释
多行注释

文档注释

// 单行注释：输出一个Hello World
//  复制上一行： ctrl+d
// 多行注释 /* 注释 */
/*
 我是多行注释
 可以注释一段文字
 */
// JavaDoc: 文档注释 /** */
/**
 * @Description HelloWorld
 * @Authod
 */

1.2 标识符

关键字：

Java 所有组成成分都需要名字。类名、变量名以及方法名都被称为标识符。
注意点：
- 所有的都应该标识符以字母、美元符($)或者下划线(_)开始
- 首字符之后可以是字母、美元符、下划线或者数字的任何字符组合
- 不能使用关键字作为变量名或者方法名
- 标识符是大小写敏感的
- 合法标识符举例： age、$salary、_value、__1value
- 非法表示：123abd、-salary
- 可以使用中文命名，但一般不建议这样使用

2. 数据类型

强类型语言
- 要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用（Java属于强类型）
  - 优点：安全性高
  - 缺点：处理速度慢
弱类型语言
- 变量的使用可以不符合规定

Java的数据类型分为两大类

基本类型（primitive type）：整数类型、浮点类型、字符类型
引用类型（reference type）：类、接口、数组

// 八大基本数据类型

        // 整数表示方式
        int num1 = 10000;//最常用
        byte num2 = 126;y
        short num3 = 30;
        long num4 = 30L;//要加L
        //JAVA的基础类型：
        /// byte的存储空间1个字节，取值范围：128~127，2的8次方-1
        /// short存储空间2个字节，取值范围-2的15次方~2的15次方-1
        /// int存储空间4个字节，取值范围-2的31次方~2的31次方-1
        /// long存储空间8个字节，取值范围-2的63次方~2的63次方-1其默认值均为0 

        // 小数：浮点数
        float num5 = 50.1F;//加F
        double num6 = 3.14159265358979;

        //字符类型(只能一个字符)，String 是类
        char name1 = 'A';
        char name2 = '罗';//只能一个字，两个字就报错
        //String是一个类

        //布尔值：是非
        boolean flag = true;

数据拓展

//整数拓展： 进制  二进制0b  十进制  八进制0  十六进制0x

        int i = 10;
        int i2 = 010; // 八进制
        int i3 = 0x10; // 十六进制 0~9 A~F

        System.out.println(i);
        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
        System.out.println(f);
        System.out.println(d);

        float d1 = 23131313123123121f;
        float d2 = d1 + 1;

        System.out.println(d1==d2);// true

        // ----------------------------------------------------------------------------
        // 字符拓展？
        // ----------------------------------------------------------------------------
        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字节  0 - 65536   2^16 = 65536

        // U0000 到 UFFFF

        char c3 = '\u0061';

        System.out.println(c3); // 输出a

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

        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！ 代码要精简易读

字节定义：

位(bit)：是计算机内部数据储存的最小单位，11001100是一个八位二进制数
字节(byte)：是计算机中数据处理的基本单位

3. 类型转换

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

低-----------------------_______________-------->高
byte,short, char -> int -> long -> float -> double

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

        long total2 = money*years;
        System.out.println(total2); // 默认是int，转换前就已经出现问题了

        long total3 = money*(long)years; // 先把一个数转换为long
        System.out.println(total3);
    }
}

4. 变量、常量、作用域

4.1 变量

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

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

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

public class Demo07 {
    public static void main(String[] args) {
        // int a,b,c;
//        int a=1,b=2,c=3;
//        尽量使用单独行定义,注意程序的可读性
        String name = "rokin";
        char x = 'X';
        double pi = 3.14;
    }
}

4.2 变量作用域

类变量
实例变量
局部变量

public class Demo08 {
    // 类变量 static
    static double salary = 2500;

    // 属性：变量

    // 实例变量：从属于对象：如果不自行初始化，这个类型的默认值是 0 0.0
    // 布尔值: 默认值是false
    // 除了基本类型，其余的默认值都是null
    String name;
    int age;


    // main 方法
    public static void main(String[] args) {

        // 局部变量：必须声明和初始化值
        int i=10;
        System.out.println(i);

        // 变量类型 变量名字 = new Demo08()；
        // new Demo08()后按alt+enter
        Demo08 demo08 = new Demo08();
        System.out.println(demo08.age); // int的默认值是0
        System.out.println(demo08.name); // String 的默认值null

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

    }

    // 其他方法
    public void add(){
       // System.out.println(i);
    }


}

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

public class Demo09 {

    // static 和 final 都是修饰符，不存在先后顺序
    static final double PI = 3.14; // 定义常量

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

4.3 变量的命名规范

所有变量、方法、类名：见名知意
类成员变量：首字母小写和驼峰原则：monthSalary 除了第一个单词以外，后面的单词首字母大写：lastName
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则：Man，GoodMan
方法名：首字母小写和驼峰原则：run(), runRun()

5. 运算符：优先级可以多使用（）

算术运算符：+, -, *, /, %(取余), ++, --
赋值运算符：=
关系运算符：>， <， >=， <=， ==， !=，instanceof
逻辑运算符：&&，||，！与或非
位运算符：&，|，^, ~, >>, <<, >>>（了解！）
条件运算符：?:
拓展赋值运算符：+=, -=, *=, /=

//算数、赋值和关系运算符
package operator;

public class Demo04 {
    public static void main(String[] args) {
        // ++  -- 自增， 自减  一元运算符
        int a = 3;

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

        // a = a + 1;
        int c = ++a; // 执行完这段代码前，先自增，再给c赋值

        System.out.println(a);
        System.out.println(b);
        System.out.println(c);

        // 幂运算 2^3 = 2*2*2 = 8 很多运算，我们会使用一些工具类来操作！
        double pow = Math.pow(2,3);
        System.out.println(pow);
    }
}

// 逻辑运算符
package operator;

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

        System.out.println("a && b："+ (a&&b)); //逻辑与运算，两个为真才为真
        System.out.println("a || b："+ (a||b)); //逻辑或运算，两个都为假结果才为假
        System.out.println("!(a && b)："+ !(a&&b));//如果真，结果假；如果加结果真

        //短路运算：因为第一个判断已经为false了，则在bool与运算判断时第二个判断不进行
        int c = 5;
        boolean d = (c<4)&&(c++<4);
        System.out.println(d);
        System.out.println(c);//c = 5

    }

}

//位运算符
package operator;

public class Demo06 {
    public static void main(String[] args) {
        /*
        A = 0011 1100
        B = 0000 1101
        上下比较：
        -----------------------
        A&B = 0000 1100
        A|B = 0011 1101
        A^B = 0011 0001 //异或：相同为0，不同为1
        ~B = 1111 0010

        -----------------------
        位运算符面试例题：
        如何最快计算 2*8 = 16 → 2*2*2*2
        观察二进制表：
        0000 0000      0
        0000 0001      1
        0000 0010      2
        0000 0011      3
        0000 0100      4
        0000 1000      8
        0001 0000      16
        可以发现
        左移：<< 相当于 *2
        右移：>> 相当于 \2
        位运算效率极高！！！
         */
        System.out.println(2<<3);
    }
}

//拓展赋值运算符
package operator;

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);//输出1020

        System.out.println(a+b+"");//输出30
    }
}

// 三元运算符
package operator;

public class Demo08 {
    public static void main(String[] args) {
        // x? y : z
        //如果x==true，则结果为y，否则结果为z

        int score = 80;
        String type = score<60?"不及格":"及格"; //必须掌握
        // if
        System.out.println(type);

    }
}

6. 包机制、JavaDoc

为了更好的组织类，Java提供了包机制，用于区别类名的命名空间，包的本质就是文件夹,package必须放在最上面
包语句的语法格式为
```
package pkg1[.pkg2[.pkg3...]]
```
一般利用公司域名倒置作为包名；com.baidu.www

效果：
为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用import语句可以完成此功能
```
import package1[.package2].(classname|*);//导入某个类
import com.kuang.base.*;//导入包下所有类
```
不要让包的名字重复

7. JavaDoc

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

package base;
//: POI/ExportConfig
/**
 * @author roking
 * @version 1.0
 * @since 1.8
 */
public class Doc {
    String name; //此为属性

    // 下为方法

    /**
     * @author
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception{
        return name;
    }
    // 课程是通过命令行 javadoc 参数 Java文件
    // 作业：学会使用IDEA产生JavaDoc文档! 面向百度编程
    // 参考资料网址：https://www.zhihu.com/question/326147443/answer/1801901651
    // https://blog.csdn.net/weixin_42140580/article/details/89635775

}///:~

posted @ 2021-07-12 16:49 rokingrow 阅读(68) 评论(0) 收藏举报

刷新页面返回顶部

rokingrow

Java基础

Java基础

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

1.1 注释

1.2 标识符

2. 数据类型

3. 类型转换

4. 变量、常量、作用域

4.1 变量

4.2 变量作用域

4.3 变量的命名规范

5. 运算符：优先级可以多使用（）

6. 包机制、JavaDoc

7. JavaDoc

公告