目录
java的编译运行
java注释
单行注释
多行注释
文档注释
基本数据类型
内置数据类型
类型默认值
动态类型var
常量
包，类，方法，对象
包
包的作用
创建包
带包的编译和运行：
包的导入（不同包中的类之间的访问）
带包名的完整路径访问。
通过导包来访问
举个栗子：
类
对象
方法
main方法：args参数
导入方法（以java.lang.Math中的方法为例）
定义方法
▪ 使用Java编程，是一种面向对象的编程方式
▪ 与C的对比：不存在独立于类的函数，编程的最基本单元为类
▪ Class（类）
▪ 包含完成某项任务的方法（methods），当任务完成时返回结果给调用者
▪ 类是Java应用程序的基本构造块
▪ 类放在“包（package）”中，“包”对应于C++中的“命名空间（name
space）”，主要用于解决同名问题。
▪ Java代码可以放到一个独立的压缩文件（.jar）中以方便部署
java的编译运行
1. Edit（编辑）: 程序员书写代码并保存到磁盘上
2. Compile（编译）: 编译器生成字节码（byte code）
3. Load（装入）: 类装载器（Class loader）在内存中保存字节码
4. Verify（校验）: 校验器Verifier保证字节码不违反安全规则
5. Execute（执行）: 解释器将字节码翻译成机器码
java注释
单行注释
单行注释以双斜杠 // 开始：
多行注释
多行注释以 /*开始，以 */结束：
文档注释
文档注释以 /** 开始，以 */ 结束，通常出现在类、方法、字段等的声明前面，用于生成代码文档，这种注释可以被工具提取并生成 API 文档，如 JavaDoc。
文档注释的格式通常包含一些特定的标签，如 @param 用于描述方法参数，@return 用于描述返回值，@throws 用于描述可能抛出的异常等等，这些标签有助于生成清晰的API文档，以便其他开发者能够更好地理解和使用你的代码。
基本数据类型
内置数据类型
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类型的变量时，需要加F作为后缀，double则不需要
- 例子：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';。
类型默认值
下表列出了 Java 各个类型的默认值：
| 数据类型 | 默认值 |
|---|---|
| byte | 0 |
| short | 0 |
| int | 0 |
| long | 0L |
| float | 0.0f |
| double | 0.0d |
| char | 'u0000' |
| String (or any object) | null |
| boolean | false |
动态类型var
使用var 定义变量的语法： var 变量名 = 初始值；（用法其实类似c++中的auto）
如果代码：
var a = 20；
var a =8.9；
这样的代码会报错 显示int到double的转换；
Java是强类型语言，每个变量都有固定的变量类型。
var不是关键字，它相当于是一种动态类型；
var动态类型是编译器根据变量所赋的值来推断类型；
var 没有改变Java的本质，var只是一种简便的写法，
就是说在定义局部变量时，任意什么类型都可以用var定义变量的类型会根据所赋的值来判断。
用var声明变量的注意事项：
1，var只能在方法内定义变量，不允许定义类的成员变量。
2，var 定义变量必须赋初始值，------》以后不能在赋初始值。
3，var每次只能定义一个变量，不能复合声明变量。
什么时候该用var定义变量：如果你定义变量时，给变量赋给一个直观的值，这时就可以使用var定义变量，
什么时候不能使用var定义变量：
1，给var定义的变量赋给一个很复杂的表达式时，这样使表达式的返回值不直观，不能用var定义变量。
2，var定义的变量作用域很长时，方法长和var变量影响较大时，不用var定义变量。
常量
如果某常量只在本类使用，则应将其定义为“private（私有）”的。
包，类，方法，对象
Java 定义了一种名字空间，称之为包：package。包是类的容器——Java中的包一般均包含相关的类。一个类总是属于某个包，类名（比如Person）只是一个简写，真正的完整类名是包名.类名，这才是唯一确定一个类路径的写法，不同包中的类名允许重复。
类就是具备某些共同特征的实体的集合，它是一种抽象的数据类型，它是对所具有相同特征实体的抽象。在面向对象的程序设计语言中，类是对一类“事物”的属性与行为的抽象。
方法的定义：方法是类或对象的行为特征的抽象。Java中的方法不能独立存在，所有的方法必须定义在类中。使用 “类名.方法” 或 “对象.方法” 的形式调用。
包
Java“包”对应于C++/C#中的“命名空间（namespace）”
包的作用
-
1、把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
-
2、如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
-
3、包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。
Java 使用包（package）这种机制是为了防止命名冲突，访问控制，提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等。
包语句的语法格式为：
package pkg1[．pkg2[．pkg3…]];
例如,一个Something.java 文件它的内容
package net.java.util; public class Something{ ... }
那么它的路径应该是 net/java/util/Something.java 这样保存的。 package(包) 的作用是把不同的 java 程序分类保存，更方便的被其他 java 程序调用。
一个包（package）可以定义为一组相互联系的类型（类、接口、枚举和注释），为这些类型提供访问保护和命名空间管理的功能。
创建包
创建包的时候，你需要为这个包取一个合适的名字。之后，如果其他的一个源文件包含了这个包提供的类、接口、枚举或者注释类型的时候，都必须将这个包的声明放在这个源文件的开头。
tips：
1、声明一个包使用关键字：package；
2、一个类中，包的声明必须放在类中第一行，每个源文件只能有一个包声明，这个文件中的每个类型都应用于它。
3、包名也是标识符全部都是小写，多级之间使用（.）隔开；一般为了避免包名重复，都是公司域名反转加项目名加模块名。如com.google.XXX
如果一个源文件中没有使用包声明，那么其中的类，函数，枚举，注释等将被放在一个无名的包（unnamed package）中。
不同路径通过点 (.) 来分割，比如这个目录/com/test，包名的话就是com.test了
带包的编译和运行：
手动式（比较麻烦，了解一下可以加深理解）
a:编写一个带包的java文件。
b:通过javac命令编译该java文件。
c:手动创建包名。（注意路径）
d:把b步骤的class文件放到c步骤的最底层包（即文件）
e:回到和包根目录在同一目录的地方，然后运行
带包运行
在命令行中用以下几行命令操作：
自动式
a:编写一个带包的java文件。
b:javac编译的时候带上-d即可
javac -d . HelloWorld.java （注意：点 . 前后之间有空格符）
c:回到和包根目录在同一目录的地方，然后运行
带包运行
只需要把前面这张图的前三行命令换成 javac -d . HelloWorld.java 即可。
包的导入（不同包中的类之间的访问）
带包名的完整路径访问。
这里以两个简单的带不同包的类为例，.java文件源代码如下：
//Test.java文件package cn.example;class Test {public static void main(String[] args) {Demo d = new Demo();System.out.println(d.sum(1,2));}
}//Demo.java文件package com.sun;public class Demo {public int sum(int a,int b) {return a + b;}
}此时直接编译运行Test会报错，因为在Test.java中找不到符合Demo
Test.java:7: 错误: 找不到符号
Demo d = new Demo();
^
符号: 类 Demo
位置: 类 Test
Test.java:7: 错误: 找不到符号
Demo d = new Demo();
^
符号: 类 Demo
位置: 类 Test
2 个错误
修改Test.java中代码如下：
//Test.java文件package cn.example;class Test {public static void main(String[] args) {//Demo d = new Demo();com.sun.Demo d = new com.sun.Demo();System.out.println(d.sum(1,2));}
}此时再编译运行，注意：一定要先编译被调用的包，否则会出现下图第一个的报错
然而，上面的方法虽然可以，如果其中的代码调用很多，每个使用到包的位置都要写上完整路径的话太麻烦了，所以通常来说用import关键字来导包
通过导包来访问
如果一个类中要使用其它包中的类，而且不止使用一次，通过上面的方式就比较麻烦，应该通过导包的方式来解决问题；
- 导包需要使用关键字：import
- 导包的位置：在包声明（package）下面，类（class）上面
- 导包的格式：import 完整包名.类名；
继续修改刚才的例子：
//Test.java文件package cn.example;
import com.sun.Demo;class Test {public static void main(String[] args) {Demo d = new Demo();//com.sun.Demo d = new com.sun.Demo();System.out.println(d.sum(1,2));}
}但如果com.sun中存在多个类时，还用上面这种导包的方法就要写好多行
import com.sun.Demo;
import com.sun.XXX1;
import com.sun.XXX2;
……
那么可以用下面这行代码来导入这个包里所有的类
import com.sun.*;
那如果不一个一个导入进来就需要使用通配符了，这个通配符就是星号(*)。这样一个是省去了很多麻烦，另外也降低了代码量。
举个栗子：
比如我们需要输入一个整数，需要导入对应包中的方法才能使用输入函数：
import java.util.Scanner;
• import 语句供编译器用来识别和定位Java程序中用到的类。
• 上述语句告诉编译器在 javax.util包中装入类 Scanner的
定义，这样在源程序代码中就可以使用它了。
import java.util.Scanner;
public class Test {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);int a = scanner.nextInt();System.out.println(a);}
}
类System 属于包java.lang，这是一个核心包，自动被每个Java程序所引入，不需要 import 语句就可以直接使用。
类
在Java中，类（Class）是一种定义对象属性和方法的蓝图或模板。它是面向对象编程中的基本概念之一。类可以包含数据成员（也称为字段或属性）和方法成员（也称为函数或操作）。
对象
在Java中，对象是类的实例化。要定义一个对象，首先需要定义一个类。类是一种模板或蓝图，描述了对象的属性和行为。然后，通过使用 new 关键字来创建类的实例，即对象。
类与对象作为java面向对象的基础，具体内容在oop中细嗦。
方法
java中的方法相当于其他语言中的函数。
main方法：args参数
▪ main()方法的参数是一个字符串数组，保存了从命令行接收到的参数，以下代码提取出所有输入的参数并打印出它们的具体值：
public class Main {public static void main(String[] args) {System.out.println("args number:"+args.length);var obj = new Object();for(String arg : args) {System.out.println(arg);}}
}可以手动运行时在后面添加参数给args：
如果希望能够不离开IDE就可以测试程序，则可以设置特定Java程序的运行时参数。
这样也能达到相同的效果。
导入方法（以java.lang.Math中的方法为例）
java.lang.Math类提供了通用的数学函数方法，这些数学函数方法都是静态方法。
所以可以用“类名.方法名”的方式直接调用
静态导入：
import static java.lang.Math.*;
这么干了之后，你就可以在Java代码中省略掉类名而只写静态方法名：（下面两种写法完全等价）
System.out.println(abs(-100));
System.out.println(Math.abs(-100));
定义方法
我们也可以开发自己的方法供其他人使用，只需创建一个类，然后为其编写声明为public的函数即可。
语法格式：
方法的返回值：
上述第一行所包容的“信息”，称为此方法的“签名”。
对于同名不同类、同类不同名的方法，方法签名的意义并不是很大，但是对于重载方法来说，方法签名的意义就十分巨大了。由于重载方法之间的方法名是相同的，那么我们势必要从构成方法的其他几个要素中找到另一个要素与方法名组成能够唯一标示方法的签名，方法体当然不予考虑。那么就是形参列表和返回值了，但是由于对于调用方法的人来说，方法的形参数据类型列表的重要程度要远远高于返回值，所以方法签名就由方法名+形参列表构成，也就是说，方法名和形参数据类型列表可以唯一的确定一个方法，与方法的返回值一点关系都没有，这是判断重载重要依据。
在Java中，方法都是放在类中的，除了那些需要被外界直接调用的“主控方法” ，其它所有的方法都应该设置为private的，不允许外界直接调用它们，这就是面向对象的“封装”原则的具体应用实例。