第一点:JAVA中的APL文档
https://docs.oracle.com/en/java/javase/18/docs/api/index.html
第二点:Java的主类结构
Java语言是面向对象的程序设计语言，Java程序的基本组成单元是类，类体中又包括属性与方法两部分。每一个应用程序都必须包含一个main()方法，含有main()方法的类称为主类。
1.包声明：一个Java应用程序是由若干个类组成。
2.声明成员变量和局部变量：类的属性称为类的全局变量（成员变量），将方法中的属性称为局部变量。全局变量声明在类体中，局部变量声明在方法体中。全局变量和局部变量都有各自的应用范围。
3.编写主方法
4.导入API类库
第三点:包的声明
//包的声明: package com.JavaBasicsDemo2.com.Class;
第四点: 标识符的定义:
1.只能由数字，字符，_(下划线)，$组成【不能以数字开头】
2.不能说java中的关键字（在java中赋予了特殊含义的一些单词）
Java的基础——>八大基本数据类型.
1、4种整数类型（byte、short、int、long）；
2、2种浮点类型（float、double）；
3、1种字符类型“char”；
4、1种布尔类型“boolean”.
第五点:八大基本数据类型具体的作用:
1 .整数数据类型：（int是高频使用的） byte：字节 占1个字节 -128~127 short：短整型 占2个字节 -2^15~ int：整型 4 -2^31~2^31-1 long：长整型 8 -2^63~2^63-1 初始值末尾要加l
2. 浮点数据类型： float：单精度 占4个字节精确到小数点后15位 要在初始值末尾加f（范围巨大） double：双精度 占8个字节 要精确到小数点后15位
3 字符数据类型： char：字符类型 占2个字节 要将字符用单引号（' '）引起来
4 布尔数据类型： boolean：1个字节 只能为true或者false
5.引用数据类型：
6. 变量的声明和初始化 //变量的声明：数据类型 变量名称； int age; //变量的初始化（给变量赋值）：变量名称=值 age = 18；
第六点:Demo实操:
package com.JavaBasicsDemo2.com.Class; //包的声明: package com.JavaBasicsDemo2.com.Class; public class Test1 { static String s1="Hellow Java 你好呀java"; //每一个程序中要定义main() 含有main 方法的的主类称为主类 public static void main(String[] args) { String s2="欢迎来到java程序设计"; System.out.println(s1); System.out.println(s2); //声明一个变量去存储我的年龄 语法：数据类型 变量名称 int age; //变量的初始化（给变量赋值） 语法：变量名称=值； age=19; System.out.println(age); } }
package com.JavaBasicsDemo2.com.Class; public class Test2 { public static void main(String[] args) { /** * 2. int类型 * 2.1. int类型 * int是最常用的整数类型，一个int类型的变量占用4个字节，即32位的内存空间。Int的最大表示范围为：-231～231-1，即-2147483648 ~2147483647，大约正负21个亿多些。 * * 2.2. 整数直接量是int类型 * 所谓整数直接量（literal）就是直接写出的整数，例如：下面的语句中，100就是直接量。 */ int a = 100; int b = 100; System.out.println("运行结果为" + a + b); //int c = 10000000000; // 编译错误10000000000这个数值写出来就是错误的，因为Java认为所有直接写出的整数都是int类型，而这个数值超过了int的表达范围。 int aa = 100000; // 10进制 System.out.println(aa); int bb = 0x186a0; // 16进制 System.out.println(bb); int cc = 0303240; // 8进制 System.out.println(cc); int aaa = 100000; // 10进制 System.out.println(aaa); int bbb = 0x186a0; // 16进制 System.out.println(bbb); int ccc = 0303240; // 8进制 System.out.println(ccc); System.out.println("--------------------------------------------"); int c = 5/3; System.out.println(c); // c的值为1，取整 int total = 87; int error = 23; int percent = error / total * 100; System.out.println(percent+"%"); //结果为0%，23除以87整数部分为0，乘以100，为0 percent = 100 * error / total; System.out.println(percent + "%"); // 结果为26%，230除以87整数部分为26 int cccc = 5/3; System.out.println(cccc); // c的值为1，取整 int total1 = 87; int error1 = 23; int percent1 = error1 / total1 * 100; System.out.println(percent1+"%"); //结果为0%，23除以87整数部分为0，乘以100，为0 percent = 100 * error / total; System.out.println(percent + "%"); // 结果为26%，230除以87整数部分为26 } }
package com.JavaBasicsDemo2.com.Class; /** * 3. long类型 * 3.1. long类型 * 在表示整数时，如果int类型的范围不够，可以使用long类型，一个long型的变量占用8个字节（即64位），最大表示范围为：-263 ~ 263-1，即 -9223372036854775808 ~ 9223372036854775807。 * * 如果要表示long直接量，需要以 L 或 l 结尾。示例代码如下： * * */ public class Test3 { public static void main(String[] args) { // a = 10000000000; //会有编译错误，因为10000000000编译器认为是int类型，而这个值，已经超出了int的范围 long b = 10000000000l; //正确 System.out.println(b); //long a = 10000000000; //会有编译错误，因为10000000000编译器认为是int类型，而这个值，已经超出了int的范围 long bb = 10000000000l; //正确 System.out.println(bb); /** * 3.2. 使用long类型进行较大整数的运算 * 对于较大的整数运算（超过int的表达范围），可以使用long型。示例代码如下： */ long distance1 = 10000 * 365 * 24 * 60 * 60 * 299792458l; //必须有一个long型数据参与的运算结果才是long型 System.out.println("distance1="+distance1);//distance1=547836957965889536 结果正确 long distance2 = 10000 * 365 * 24 * 60 * 60 * 299792458; System.out.println("distance2="+ distance2); //distance2=-1973211136 溢出，=号后面的数据默认为int类型，超出了范围，发生溢出。 // long cc = 10000 * 365 * 24 * 60 * 60 * 299792458l; //必须有一个long型数据参与的运算结果才是long型 System.out.println("distance1="+distance1);//distance1=547836957965889536 结果正确 //long dd = 10000 * 365 * 24 * 60 * 60 * 299792458; System.out.println("distance2="+ distance2); //distance2=-1973211136 溢出，=号后面的数据默认为int类型，超出了范围，发生溢出。 } }
package com.JavaBasicsDemo2.com.Class; public class Test4 { public static void main(String[] args) { /** * 4. double类型 * 4.1. 使用double进行浮点数的运算 * 前面所学习的int、long都是用于存储整数的，小数即为浮点数，包括： float（单精度）和double（双精度）， * double类型的精度值是float类型的两倍，因此而得名双精精，在实际的应用开发中，float应用极少， * 大多数场合使用double表示浮点数。示例代码如下： */ double pi = 3.14; double r = 8; double s = pi * r * r; System.out.println("s=" + s); // 输出的结果为：s=200.96 double pis = 3.14; double rr = 8; double ss = pis * r * r; System.out.println("s=" + ss); // 输出的结果为：s=200.96 /** * 4.2. 浮点数直接量是double类型 * 浮点数的直接量有两种写法：1）通常写法，如：3.14、314、0.1、.5。 2）科学计数法， * 如：1.25E2、1.25e2、1.25E-2。其中，1.25E2表示1.25乘以10的2次方。 * 默认的浮点直接量为double型，如果需要表示float类型的直接量，需要加“f”或“F”后缀。例如： */ float f1 = 3.14f; //编译错误，应该写成3.14f System.out.println(f1); // float f1 = 3.14 //编译错误，应该写成3.14f /** * 4.3. double运算时会出现舍入误差 * 2进制系统中无法精确的表示1/10，就好像十进制系统中无法精确的表示1/3一样， *所以，2进制表示10进制会有一些舍入误差，对于一些要求精确运算的场合会导致代码的缺陷。示例代码如下所示： */ double money = 3.0; double price = 2.9; System.out.println(money - price); //输出的结果是： 0.10000000000000009 double moneys = 3.0; double prices = 2.9; System.out.println(moneys - prices); //输出的结果是： 0.10000000000000009 } }
package com.JavaBasicsDemo2.com.Class; public class Test5 { public static void main(String[] args) { /** * 5. char类型 * 5.1. char类型 * 字符类型char事实上是一个16位无符号整数（都是正数），这个值是对应字符的编码， * Java字符类型采用Unicode字符集编码（通用码、统一码、万国码），而Unicode是世界通用的定长字符集，所有的字符都是16位来表示。例如：字符a实际的值为97，字符A实际的值为65，字符0实际的值为48。 * * 字符直接量可以采用诸如：‘中’的形式，也可以采用16进制的表示形式，例如： ‘\u4e2d’，代码如下所示： */ //char c1 = ‘中’; //c1中存的是”中”的编码 char c2 = '\u4e2d'; //‘4e2d’为‘中’所对应的16位Unicode编码的16进制表示形式 //System.out.println(c1); System.out.println(c2); //char c1 = ‘中’; //c1中存的是”中”的编码 //char c2 = '\u4e2d'; //‘4e2d’为‘中’所对应的16位Unicode编码的16进制表示形式 //System.out.println(c1); //System.out.println(c2); // 如上代码的输出结果：c1的值为中，c2值也为中，但c1和c2内部存储的其实是”中”这个字符所对应的Unicode码，即：一个无符号的整数。 /** * 5.2. 对char型变量赋值 * 在对char型变量赋值时，可以采用如下三种方式： * * 方式一： * * 字符直接量：形如‘A’，变量中实际存储的是该字符的Unicode编码（无符号整数值），一个char型变量只能存储一个字符。示例如下： */ char c1 = 'A'; //char c1 = 'A'; /** * 方式二： * * 整型直接量：范围在0~65535之间的整数，变量中实际存储的即该整数值，但表示的是该整数值所对应的Unicode字符。示例如下： */ //char c2 = 65; //char c2 = 65; //Unicode形式：形如‘\u0041’,Unicode字符的16进制形式。示例如下： //char c3 = '\u0041'; /** * 5.3. 使用转义字符 * 字符直接量需要包含在一对’’单引号之中，那如果想表示单引号’的字符时，需要怎么表示？想表示回车、换行符时，怎么表示？ * * 因为单引号为特殊意义的字符， 那么，对于不方便输出的字符可以采用转义字符来表示，示例代码如下： */ char c = '\\'; System.out.println(c); //输出的结果为：\ char cc = '\\'; System.out.println(c); //输出的结果为：\ } }
package com.JavaBasicsDemo2.com.Class; public class Test6 { public static void main(String[] args) { /** * 6. boolean类型 * 6.1. 使用boolean变量进行关系运算 * boolean类型适用于关系、逻辑运算， 表示某个条件是否成立， 只允许取值true或false，true表示条件成立， 而false表示条件不成立。 * * boolean型变量经常用于存储关系运算的结果，所谓关系运算就是比较两个变量的大小相等等关系（此知识点，后续详细介绍）。boolean示例代码如下所示： */ int age = 18; boolean isChild = age<16; System.out.println(isChild); // isChild的值为false boolean running = true; boolean closed = false; int ages = 18; boolean isChilds = age<16; System.out.println(isChilds); // isChild的值为false boolean runnings = true; boolean closeds = false; } }
（驼峰式命名）：如果命名有多个单词，那么首个单词首字母小写，后面的首字母都大写 注意： 数据类型小到大排列：byte<short<int<<long<float<double 整数数据类型要小于浮点数 如果多个数据类型的数据参与运算，最终结果会是多个类型中最大的数据类型 将小的数据类型的变量赋值给大的数据类型的变量 我们称为“自动类型转换” 大的 数据类型无法赋值给小的数据类型（强制类型转换：格式“小数据类型变量 = 大数值类型变量” 可将大类赋值给小类，但会出现各种问题）
package com.JavaBasicsDemo2.com.Class; public class Test7 { public static void main(String[] args) { /** * 7. 基本类型间转换 * 7.1. 类型间转换 * 不同的基本类型直接可以相互转化，主要有两种方式： * * 自动类型转化（隐式类型转换）：从小类型到大类型可以自动完成。类型的大小关系如下图 - 3所示： * 强制转化：从大类型到小类型需要强制转换符，语法如下： * * * （需要转换成的类型）变量 * * 因为大类型的精度值大于小类型，取值范围大于小类型，所以，当使用强制转化时，有可能会造成精度的损失或者溢出，所以，在使用强制转化时要求显式的告诉编译器，正在进行强制转换。 * * 7.2. 强制转换时的精度丧失和溢出 * 基本类型转化如下示例所示，注意强制转换时可能会造成的精度丧失和溢出。 */ int a = 100; int b = 200; long c = a + b; //自动将int转化为long long l1 = 1024l; int i = (int) l1; //需要加强制转化符由于1024在int的范围内，所以没有产生溢出 long l = 1024L * 1024 * 1024 * 4; int j = (int) l; //会产生溢出 System.out.println(j); // 结果为：0 double pi = 3.1415926535897932384; float f = (float) pi; //会造成精度的损失，因为单精度的精确度小于double System.out.println(f); //结果为：3.1415927 int aa = 100; int bb = 200; long cc = aa + bb; //自动将int转化为long long l11 = 1024l; int s = (int) l11; //需要加强制转化符由于1024在int的范围内，所以没有产生溢出 System.out.println(s); long ls = 1024L * 1024 * 1024 * 4; int js = (int) ls; //会产生溢出 System.out.println(js); // 结果为：0 double pis = 3.1415926535897932384; float fs = (float) pis; //会造成精度的损失，因为单精度的精确度小于double System.out.println(fs); //结果为：3.1415927 /** * 7.3. 数值运算时的自动转换 * 如果在一个表达式中出现了多种数据类型，则运算结果会自动的向较大的类型进行转化， * * 示例如下： */ //由于有long型的直接量参与，整个表达式的结果为long long distance = 10000 * 365 * 24 * 60 * 60 * 299792458l; //由于有double型的直接量599.0参与，整个表达式的结果为 double double change = 800 - 599.0; //结果为0.0，右边都是int型数据运算结果也为int类型，结果为0，再赋值给double //将0转化为 0.0 double persent1 = 80 / 100; //结果为0.8，右边表达式有double型直接量参与， 运算结果为double型 double persent2 = 80.0 / 100; //由于有long型的直接量参与，整个表达式的结果为long long distancew = 10000 * 365 * 24 * 60 * 60 * 299792458l; System.out.println(distancew); //由于有double型的直接量599.0参与，整个表达式的结果为 double double changes = 800 - 599.0; System.out.println(changes); //结果为0.0，右边都是int型数据运算结果也为int类型，结果为0，再赋值给double //型，将0转化为 0.0 double persent = 80 / 100; //结果为0.8，右边表达式有double型直接量参与， 运算结果为double型 double persents = 80.0 / 100; /** * 7.4. byte、char、short转换为int * 在前面所介绍的8种数据类型中，byte、char、short、int、long都表示整数类型，而整型的直接量为int，在实际使用中，为了方便使用，遵循了如下的规则： * * int直接量可以直接赋值给byte、char和short，只要不超过其表示范围。示例如下： */ // byte bb = 97; short ss = 97; char ccc = 97; byte bbb = 97; short ssss = 97; char cccc = 97; // byte、char、short三种类型参与运算时，先一律转换成int类型再进行运算。示例如下： // byte b = 97; int num = b + b; //num的值为194 } }
