java学习之路——java基础

一、java基础 1、Hello，word！

public class Hello {
    public static void main(String[] args) {
        System.out.println("hello word!");
    }
}

2、注释

单行注释、多行注释、文档注释

public class Hello {
    public static void main(String[] args) {
        System.out.println("hello word!");
        // 单行注释：

        

        //javaDoc:文档注释   
        
    }
}

3、关键字与标识符 3.1关键字

3.2标识符

4、数据类型

• 强类型语言
• • 要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用
• 弱类型语言
• Java的数据类型分为两大类
• • 基本类型（Primitive type）
• • 引用类型（reference type)

4.1基本类型（Primitive type）

Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。
byte：
byte 数据类型是8位、有符号的，以二进制补码表示的整数；
最小值是 -128（-2^7）；
最大值是 127（2^7-1）；
默认值是 0；
byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
例子：byte a = 100，byte b = -50。

short：
short 数据类型是 16 位、有符号的以二进制补码表示的整数
最小值是 -32768（-2^15）；
最大值是 32767（2^15 - 1）；
Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
默认值是 0；
例子：short s = 1000，short r = -20000。

int：
int 数据类型是32位、有符号的以二进制补码表示的整数；
最小值是 -2,147,483,648（-2^31）；
最大值是 2,147,483,647（2^31 - 1）；
一般地整型变量默认为 int 类型；
默认值是 0 ；
例子：int a = 100000, int b = -200000。

long：
long 数据类型是 64 位、有符号的以二进制补码表示的整数；
最小值是 -9,223,372,036,854,775,808（-2^63）；
最大值是 9,223,372,036,854,775,807（2^63 -1）；
这种类型主要使用在需要比较大整数的系统上；
默认值是 0L；
例子： long a = 100000L，long b = -200000L。
"L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。

float：
float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
float 在储存大型浮点数组的时候可节省内存空间；
默认值是 0.0f；
浮点数不能用来表示精确的值，如货币；
例子：float f1 = 234.5f。

double：
double 数据类型是双精度、64 位、符合 IEEE 754 标准的浮点数；
浮点数的默认类型为 double 类型；
double类型同样不能表示精确的值，如货币；
默认值是 0.0d；
例子：
double d1 = 7D ;
double d2 = 7.;
double d3 = 8.0;
double d4 = 8.D;
double d5 = 12.9867;
7 是一个 int 字面量，而 7D，7. 和 8.0 是 double 字面量。

boolean：
boolean数据类型表示一位的信息；
只有两个取值：true 和 false；
这种类型只作为一种标志来记录 true/false 情况；
默认值是 false；
例子：boolean one = true。

char：
char 类型是一个单一的 16 位 Unicode 字符；
最小值是 u0000（十进制等效值为 0）；
最大值是 uffff（即为 65535）；
char 数据类型可以储存任何字符；
例子：char letter = ‘A’;。

import javax.swing.plaf.TreeUI;

public class Demo01 {
    public static void main(String[] args) {
        //八大基本数据类型

        //整数
        int num1 =10;  //常用//
        byte num2 = 100;
        short num3 = 40;
        long num4 = 60L;  // L表示long类型的区分

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

        //字符
        char name = 'J';

        //字符串
        String namea = "jjl";

        //布尔值
        boolean flag = true;
        //boolean flag = false;
    }
    
}

4.2引用类型（reference type)

引用类型（reference type) ——》 （类、接口、数组）

4.3拓展

public class Demo02 {
    public static void main(String[] args) {
        // 整数拓展 进制 二进制0b 十进制 八进制0 十六进制0x

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

        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);

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

        // 浮点拓展？ 银行业务怎么表示？？
        // float 能表示的位数有限，数据离散，存在舍入误差 大约 接近但是不等于
        // 最好完全不要用浮点数进行比较
        // 最好使用BigDecimal 数学工具类
        // double

        float f = 0.1f; // =0.1
        double d = 1.0 / 10; // =0.1
        System.out.println(f == d); // 讲道理因该输出true，但是结果输出的是false。
        System.out.println(f);
        System.out.println(d);

        float d1 = 23332323232323232323f;
        float d2 = d1 + 1;
        System.out.println(d1 == d2);

        // ============================================
        // 字符串拓展
        char c1 = 'a';
        char c2 = '中';

        System.out.println(c1);
        System.out.println((int) c1); // 强制将字符转换为Unicode编码
        System.out.println(c2);
        System.out.println((int) c2);// 强制将字符转换为Unicode编码
        // 所有的字符本质还是数字
        // Unicode编码：U0000 UFFFF
        char c3 = 'u0061'; // a
        System.out.println(c3);

        // 转义字符
        // t 制表符
        // n 换行
        System.out.println("hellotword");
        System.out.println("hellonword");

        //布尔值扩展
        boolean flag = true;
        // if (flag==true) = if(flag)
        if (flag==true){

        }
    }
}

输出：

10
8
16
===================================================================
false
0.1
0.1
true
a
97
中
20013
a
hello   word
hello
word

5、类型转换

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

低 ------------------------------------------高
byte,short,char—> int ---->long----->float----->doublie

• 运算中，不同类型的数据先转化为同一类型，然后进行运算
• 强制类型转换
• 自动类型转换

public class Demo04 {
    public static void main(String[] args) {
        int i = 128;

        // 变量类型，从高——低，需要强制转换
        // 强制转换，由于byte的范围为：+-127，这里是128，则就会出现内存溢出的情况，就会转换成一个未知的数
        byte b = (byte) i;

        System.out.println(i);
        System.out.println(b);

        int i1 = 10;
        byte b1 = (byte) i1;
        System.out.println(i1);
        System.out.println(b1);

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

        // 变量类型，从底——高，不需要强制转换
        double b2 = i;
        System.out.println(b2);

        
        System.out.println("==============================");
        System.out.println((int) 23.7);
        System.out.println((int) -45.89f);

        char c = 'a';
        int d = c + 1;
        System.out.println(d);
        System.out.println((char) d);

    }
}

输出结果：

128
-128
10
10
==============================
128.0
==============================
23
-45
98
b

补充：内存溢出问题

public class Demo05 {
    public static void main(String[] args) {
        // 操作比较大的数的时间，注意溢出问题
        // JDK新特性，数字之间可以用下划线
        int money = 1_000_000_000;
        System.out.println(money);
        int year = 20;
        int total = money * year;
        System.out.println(total); // 结果：-1474836480，内存溢出

        long total123 = money * ((long) year);
        System.out.println(total123); 
    }
}

输出结果：

1000000000
-1474836480
20000000000

6、变量

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

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

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

public class Demo07 {
    // 类变量 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 Demo07();
        Demo07 demo07 = new Demo07();
        System.out.println(demo07.age);
        System.out.println(demo07.name);

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

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

    }
}

输出结果：

10
0
null
2500.0

7、常量

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

public class demo08 {
    static final double PI = 3.14;
    public static void main(String[] args) {
        System.out.println(PI);
    }
}
输出：
3.14

7.1变量的命名规范

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

8、运算符

Java语言支持如下运算符：

• 算术运算符：+，-，-*，/，%，++，-- (%取余）
• 赋值运算符=
• 关系运算符：<,>,>=,<=,==,!=instanceof
• 逻辑运算符：&&，|| ，！ （与或非）
• 位运算符：& ，|， ……， ~， >>, <<, >>>
• 条件运算符： ？：
• 扩展赋值运算符：+=，-=，*=，/=

8.1二元运算

普通 + - * /

package operator;

public class Demo01 {
    public static void main(String[] args) {
        // 二元运算符
        int a = 10;
        int b = 20;
        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b);
        System.out.println(a / b);
        System.out.println(a / (double) b);
    }
}

结果

30
-10
200
0
0.5

8.2运算过程中字符类型变化

package operator;

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

        // 如果操作类型中有一个为long，则结果就是long，如果有一个为doubale，那么结果就是double，否则就为int
        System.out.println(a + b + c + d); // long
        System.out.println(b + c + d); // int
        System.out.println(c + d); // int
    }
}

结果

123131123132132273
141
18

8.3关系运算

package operator;

public class Demo03 {
    public static void main(String[] args) {
        // 关系运行算符返回结果： 正确，错误 布尔值
        int a = 10;
        int b = 20;
        int c = 21;

        System.out.println(a > b);
        System.out.println(a < b);
        System.out.println(a == b);
        System.out.println(a != b);
        System.out.println(c % a);
    }
}

结果

false
true
false
true
1

8.4一元运算

package operator;

public class Demo04 {
    public static void main(String[] args) {
        // ++ -- 自增 自减 一元运算符
        int a = 3;
        System.out.println(a);
        int b = a++; // 执行这行代码后，给b赋值，然后a自增加1
        // a = a + 1
        System.out.println(a);
        // a = a + 1
        int c = ++a; // 执行这行代码前，先a自增加1，再给b赋值
        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);

    }
}

结果

3
4
5
3
5
8.0

8.5逻辑运算

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)); // 结果取反

        // 短路运算 当进行逻辑与运算时，如果发现第一个变量为假了，则结果就直接为假了，而不会再去运算后面第二个变量的值了
        int c = 5;
        boolean d = (c < 4) && (c++ < 4); // 如果执行了(c++ < 4)，则c就会变成6
        System.out.println(d);
        System.out.println(c);

    }

}

结果

a && b:false
a || b:true
! (a && b):true
false
5

8.6、位运算

package operator;

public class Demo06 {
    public static void main(String[] args) {
        // 位运算，是通过二进制的方式进行运算 效率极高
        
        System.out.println(2 << 3); // 左移三位
        
    }
}

结果

16

8.7连接符

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);

        // 字符串连接符
        System.out.println(a + b);
        System.out.println("and" + a + b); // 如果字符串在前面，则会将后面的识别位字符串连接起来
        System.out.println(a + b + "and"); // 如果字符串在后面，则会将前面的先运算然后再连接起来

    }
}

结果

30
50
and3020
50and

8.8、三元运算

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 ? "不及格" : "及格";
        System.out.println(type);
    }
}

结果

及格

9、包机制

• 为了更好地组织类，Java提供了包机制，用于区别类名的命名空间。
• 包语句的语法格式为：

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

• 一般利用公司域名倒置作为包名；
• 为了能够使用某一个包，我们需要再Java程序中明确导入该包，使用import语句乐意完成

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

package com;
import java.util.date;
import com.jjl.operator.*;

public class date {
    public static void main(String[] args) {
        date
    }
}

10、JavaDoc生成文档

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

package com.jjl.base;


public class Doc {
    String name;
    
    public String test(String name) throws Exception{
        return name;
    }
}

生成JavaDoc文档，cmd里面

E:study_fileJavahellocomjjlbase>javadoc -encoding UTF-8 -charset UTF-8 Doc.java
正在加载源文件Doc.java...
正在构造 Javadoc 信息...
标准 Doclet 版本 1.8.0_251
正在构建所有程序包和类的树...
正在生成.comjjlbaseDoc.html...
Doc.java:14: 警告: @param 没有说明
     * @param name
       ^
Doc.java:15: 警告: @return 没有说明
     * @return
       ^
Doc.java:16: 警告: @throws 没有说明
     * @throws Exception
       ^
正在生成.comjjlbasepackage-frame.html...
正在生成.comjjlbasepackage-summary.html...
正在生成.comjjlbasepackage-tree.html...
正在生成.constant-values.html...
正在构建所有程序包和类的索引...
正在生成.overview-tree.html...
正在生成.index-all.html...
正在生成.deprecated-list.html...
正在构建所有类的索引...
正在生成.allclasses-frame.html...
正在生成.allclasses-noframe.html...
正在生成.index.html...
正在生成.help-doc.html...
3 个警告

会自动创建这些文件

双击index.html浏览