节点1：环境搭建，Java基础语法

1. 环境搭建

版本：
J2SE、J2EE、J2ME
下载并安装JDK
JDK(Java Develop Kit):开发工具包
JRE(Java Runtime Environment):运行时环境
配置环境变量
右键—>计算机—>选择“属性”—>点击“高级系统设置”—>打开“系统属性”窗口—>点击“环境变量”
（1）新建“JAVA_HOME”环境变量，值设置为：JDK的安装目录
（2）修改“Path”环境变量，添加“;%JAVA_HOME%\bin;”
（3） Classpath(可选)
验证是否安装成功：
打开“运行”—>输入cmd—>在命令提示符窗口，输入java –version,如果能够出现如下界面，则安装成功！

2. 第一个Java程序

创建文件名为HelloWorld.java的源文件：

//定义一个公共类，类名HelloWorld
public class HelloWorld{//类体-main方法public static void main(String[] args){//方法体System.out.print("Hello World!");}
}

运行Java程序：
（1）打开“运行”，输入cmd，打开命令提示符窗口
（2）切换目录
a) 切换盘符： e:
b) 切换目录： cd billfox（cd—change directory）
c) 编译程序： javac HelloWorld.java（编译源文件，获得class字节码文件）
d) 运行程序： java HelloWorld（运行字节码文件）

3. 开发工具的安装使用

安装版.exe
解压版

4. 使用Eclipse创建Java项目

包名：反域名制（com.taobao.projectName）
类名：所有单词首字母要大写！(UpperCamelCase驼峰命名法 StudentCount)
变量名,方法名，参数名：(lowerCamelCase驼峰命名法 studentCount)
常量：所有字母大写，每个单词之间用下划线隔开。 MAX_STOCK_COUNT

命名规范：由字母，数字，下划线和$组成，不能以数字开头。
比如：num1 num_1 $num

5. Java编程基础

1) 变量

语法：数据类型变量名 [= 值];
例子：int count = 10;
float studentWeight;

标识符和关键字
标识符：是用来表示变量名、类名、方法名、数组名和文件名的有效字符序列。
关键字：是Java语言中被赋予特定含义的一些单词。

变量的作用域

public class Demo01 {public static void main(String[] args) {//变量的作用域int x = 10;{//代码块int y = 20;System.out.println(y);System.out.println(x);}System.out.println(y);//报错，超出了y的作用范围System.out.println(x);}
}

2) 数据类型( 四类8种)

（1）整数型
a) 字节型byte 1个字节（8位） -27 ~27-1
b) 短整型short 2个字节（16位） -215 ~215-1
c) 整型int 4个字节（32位） -231 ~231-1
d) 长整型long 8个字节（64位） -263 ~263-1
（2）浮点数类型
a) 单精度浮点 float 4个字节
b) 双精度浮点 double 8个字节
（3）布尔型 boolean (true,false)
（4）字符型 char

数据类型转换
（1）自动类型转换（小转大）
byte–>short–>char–>int–>long–>float–>double
例子：
int num = 20;
float f1 = num;
（2）强制类型转换（大转小）
例子：
float f2 = 2.5f;
int num2 = (int)f2;//有可能损失精度或者溢出
（3）字符串型数据和整型数据相互转换 “10” 10
a) 字符串转数字 int num = Integer.parseInt(“10”);
b) 数字转字符串 String str = 10 + “”;

3) 输入输出

输出：
System.out.print(输出的内容); //不换行
System.out.println(输出的内容); //输出内容后换行
输入：
Scanner sc = new Scanner(System.in);//简易的文本扫描器
int I = sc.nextInt();//获取输入的整数
float f = sc.nextFloat();//获取输入的单精度浮点数
double d = sc.nextDouble();//获取输入的双精度浮点数
String s = sc.next();//获取输入的字符串

代码提示配置
参考https://www.cnblogs.com/zgqys1980/p/5067337.html
主动触发代码提示的快捷键：Alt + /
字体大小配置
Window->preferences->搜索”font”->选择”Colors and Fonts”->选择右侧列表中Basic下的Text Font,然后点击编辑（Edit）按钮，修改你想要的字体大小即可。

4) 常量

符号常量：final double PI = 3.1415926;
字面常量：10、2.5、’a’

5) 运算符

1. 算术运算符

+、-、*、/、%、++（前/后）、–（前/后）

注意：
/ 当两个运算数为整数时，为取整运算。
/ 当两个运算符不全为整数时，为除法运算。

c = a++;//先把a的值赋给c,然后a再自增
c = ++a;//先把a的值自增，然后把a赋给c

2. 关系运算符

、<、>=、<=、==、!=

由关系运算符构成的关系表达式，返回值为布尔值，即true/false.

3. 逻辑运算符

&&（短路与）、||（短路或）、!、&（非短路与）、|（非短路或）、^（异或）

逻辑运算符，用于连接关系表达式（boolean），最终的结果，也是布尔值（boolean）。

4. 位运算符

5. 赋值运算符

=、+=、-=、*=、/=、%=

a += 10；// 等价于 a = a + 10;

6. 条件运算符

表达式1?表达式2：表达式3;

“表达式1”是一个结果为布尔值的逻辑表达式。也就是返回值为true/false
运算规则：
如果表达式1返回true,则整个表达式的返回值为表达式2；否则返回表达式3；

7. 字符串运算符

其实就是对字符串进行拼接。

8. 运算符的优先级

. [] ()
算术运算符
关系运算符
逻辑运算符
条件运算符
赋值运算符

6) 流程控制语句

1. 顺序结构

2. 分支结构

单分支if
双分支if…else…
多分支
a) If…else if…else if…else
b) Switch(表达式){case 值1：break; default:break;}
分支结构嵌套

3. 循环结构

While
Do…while
For
Foreach增强for循环

4. 跳转语句

break;//结束循环
continue;//退出本次循环，进入下一次
return;//退出方法

7) 数组

1. 数组的定义

 （1）int[] scores;//声明scores = new int[45];//初始化（2）int[] scores = new int[45];//声明数组的同时初始化（3）静态初始化int[] arr = new int[] {1,2,3,4,5,6};int[] arr =  {1,2,3,4,5,6};

2. 数组的赋值

     scores[0] = 10;scores[1] = 15;

3. 数组的常用操作

 数组遍历数组最值（最大值，最小值）数组排序（冒泡排序，选择排序）数组元素的删除，修改

4. Arrays

 排序 sort查询 binarySearch复制 copyOf转字符串 toString填充 fill

8) 方法

1. 方法的定义

[修饰符] 返回值类型方法名([参数类型参数名1，参数类型参数2…]){
//方法体
}

例子：

public static void printStar(int line,int column) {for(int i = 0;i < line;i++) {//打印第i行： //打印j个星号for(int j=0;j<column;j++) {System.out.print("*");}//打印换行System.out.println();}
}

2. 方法的分类

（1）无返回值无参数

public class Demo02 {public static void main(String[] args) {welcome();}public static void welcome() {System.out.println("**************");System.out.println("***  欢迎光临   ***");System.out.println("**************");}
}

（2）无返回值有参数

public class Demo03 {public static void main(String[] args) {welcome("Hello");}public static void welcome(String content) {System.out.println("**************");System.out.println("***  "+content+"  ***");System.out.println("**************");}
}

（3）有返回值无参数

public class Demo04 {public static void main(String[] args) {int num = getNum();//System.out.println(num);}//有返回值public static int getNum() {//创建随机类Random rad = new Random();//int n = rad.nextInt(); //获得一个随机数int n = rad.nextInt(); //获得一个bound范围之内的随机数， 10   [0,10)   n>=0  n<10return n;}
}

（4）有返回值有参数

public class Demo05 {public static void main(String[] args) {int sum = add(8, 5);System.out.println(sum);}//加法public static int add(int n1,int n2) {int result = n1 + n2;return result;}
}

节点2：Java面向对象编程

1. 面向对象编程思想

与面向过程编程思想的区别：
可以拿生活中的实例来理解面向过程与面向对象，例如五子棋，面向过程的设计思路就是首先分析问题的步骤：1、开始游戏，2、黑子先走，3、绘制画面，4、判断输赢，5、轮到白子，6、绘制画面，7、判断输赢，8、返回步骤2，9、输出最后结果。把上面每个步骤用不同的方法来实现。

如果是面向对象的设计思想来解决问题。面向对象的设计则是从另外的思路来解决问题。整个五子棋可以分为1、黑白双方，这两方的行为是一模一样的，2、棋盘系统，负责绘制画面，3、规则系统，负责判定诸如犯规、输赢等。第一类对象（玩家对象）负责接受用户输入，并告知第二类对象（棋盘对象）棋子布局的变化，棋盘对象接收到了棋子的变化就要负责在屏幕上面显示出这种变化，同时利用第三类对象（规则系统）来对棋局进行判定。

2. 类和对象的概念：

• 对象：对象是类的一个实例（对象不是找个女朋友），有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。（具体）
• 类：类是一个模板，它描述一类对象的行为和状态。（抽象）

3. 类的设计

1) 类的构成：

（1）成员变量
（2）成员方法
（3）构造方法
特点：
1.构造方法的方法名必须和类名一致。
2.没有返回值类型。
（4）类成员

类变量（静态变量）访问：类名.类变量
类方法（静态方法）访问：类名.类方法()
静态代码块

/** 类的设计* 1）成员变量* 2）成员方法* 3）构造方法* * 4）类成员*    a.类变量*      b.类方法*      c.静态代码块* * * 类,其实一种用户自定义的数据类型。* * 编码规范：驼峰命名法*/
public class Student {//1.成员变量String name;String sex;int age;//2.成员方法public void study() {System.out.println(name+"在学Java,在"+school);//成员方法可以访问类变量，但类方法不能访问成员变量。}public void playGame() {System.out.println(name+"在玩王者荣耀");}//3.构造方法/** 特点：* 1.构造方法的方法名要和类名一致。  * 2.没有返回值类型。* ---3.一般情况下，用public来修饰。*/public Student() {System.out.println("--构造方法执行--");count++;}//4.类变量(静态变量)static String school;static int count;//当前类的对象个数//5.类方法（静态方法）public static void count() {System.out.println("学校共有"+ count+"个学生 。");}//6.静态代码块static {//对类进行初始化count = 0;System.out.println("--学校构建完成。--");}
}

2) 参数的传递（值传递）

基本数据类型：变量值
引用数据类型：内存值

了解：InstanceOf:判断某个对象是否是某个类的对象。 S1 instanceof Student

方法重载
方法重载的特点：

在同一个类中
方法名相同
参数的个数或者类型不同
public class Actor {
String name;

//表演
public void act() {
System.out.println(“唱歌”);
}

public void act(String instrument) {
System.out.println(“边弹” + instrument +“边唱”);
}

public void act(int n) {
System.out.println(“循环唱” + n +“次”);
}
}

方法重载，包括：
成员方法重载
构造方法重载。
public class Actor {
//成员变量
String name;
String sex;
int age;

//成员方法重载
public void act() {
System.out.println(“唱歌”);
}

public void act(String instrument) {
System.out.println(“边弹” + instrument +“边唱”);
}

public void act(int n) {
System.out.println(“循环唱” + n +“次”);
}

//构造方法重载
public Actor() {
}

public Actor(String actorName) {
name = actorName;
}

public Actor(String actorName,String actorSex) {
name = actorName;
sex = actorSex;
}

public Actor(String actorName,String actorSex,int actorAge) {
name = actorName;
sex = actorSex;
age = actorAge;
}
}

补充：可变参数
//求整数的和(可变参数)
public int add(int… nums) {
int sum = 0;
for (int i = 0; i < nums.length; i++) {
sum = sum + nums[i];
}
return sum;
}

this
this指当前类的对象
public Actor(String name,String sex,int age) {
this.name = name;//当前要创建的对象的name属性 = name参数;
this.sex = sex;
this.age = age;
}
通过this关键字
1.可以调用当前类的成员变量。
2.可以调用当前类的成员方法。
3.可以调用当前类的构造方法。
public class Student {
String name;
String sex;

public void study() {
System.out.println(this.name+“在学习”);//1.通过this调用成员变量
}

public void race() {
this.study();//2.通过this调用成员方法
System.out.println(“参加比赛！”);
}

public Student() {

}

public Student(String name){
this();//3.通过this调用无参构造
this.name = name;
}
}

节点3：封装，继承，多态

封装
实现步骤：
(1)属性私有化 (2)提供公共的getter,setter方法
自动生成get,set方法：右键—>Source—>Generate Getters and Setters

public class Actor {//成员变量private String name;private String sex;private int age;//提供公共的get,set方法public void setName(String name) {this.name = name;}public String getName() {return this.name;}public void setSex(String sex) {if (sex.equals("男") || sex.equals("女")) {this.sex = sex;}else {System.out.println("您设置的性别有误！");}}public String getSex() {return this.sex;}public void setAge(int age) {if (age < 0 || age > 130) {System.out.println("您设置的年龄有误！");}else {this.age = age;}}public int getAge() {return this.age;}//成员方法 重载public void act() {System.out.println("唱歌");}public void act(String instrument) {System.out.println("边弹" + instrument +"边唱");}public void act(int n) {System.out.println("循环唱" + n +"次");}//构造方法  重载public Actor() {}public Actor(String name) {this.name = name;}public Actor(String name,String sex) {this.name = name;this.sex = sex;}public Actor(String name,String sex,int age) {this.name = name;this.sex = sex;this.age = age;}
}

继承

继承的概念：
可以基于已经存在的类构造一个新类。继承已经存在的类就可以复用这些类的方法和域。在此基础上，可以添加新的方法和域，从而扩充了类的功能。

继承的关键字：extends
继承的特点：
1. 可以实现代码的复用—子类拥有父类非私有的属性和方法。
2. 子类可以对父类进行扩展—子类可以拥有自己的属性和方法。
3. 方法重写—子类可以用自己的方式去实现父类的方法。
4. 单继承，可以多重继承
5. 缺点：提高了代码的耦合度。

例子：
定义父类：

public class Animal {//父类定义子类共有的属性和行为String name;String sex;int age;String color;public void eat() {System.out.println(name + "吃东西");}
}

定义子类-Cat：

public class Cat extends Animal{//猫类特有的行为public void catchMouse() {System.out.println(name+ "抓老鼠...");}
}

定义子类-Dog：

public class Dog extends Animal {//狗类特有的行为public void guard() {System.out.println(name + "看家");}}

修饰符
（1）访问修饰符
a) public:所有类都可以访问。 (当前类，同一个包中的不同类，不同包的类)
b) protected：包的访问权限+不同包的子类 (当前类，同一个包中的不同类,不同包的子类)
c) 缺省:包的访问权限。 (当前类，同一个包中的不同类)
d) private:当前类 (当前类)
（2）非访问修饰符
a) static
i. 修饰成员变量，则成员变量变为类变量。static String school = “莱职”;
ii. 修饰成员方法，则成员方法变为类方法。
iii. 修饰代码块，则代码块变为静态代码块。特点：是在main方法之前运行，而且只运行一次。其实就是在类加载时运行。
b) final
i. 修饰变量，则变量变成不可改变的量，即常量。 final int num = 10;
ii. 修饰方法，则方法变为不可重写的方法。
iii. 修饰类，则类变为不可继承的类。
c) abstract 抽象
方法重写
特点：
1.要有继承，重写发生在两个类之间，子类去重写父类的同名的方法
2.子类的方法名要和父类的方法名相同，而且参数（个数，类型）也要完全一致。
3.子类对方法的修饰，只能扩大，不能缩小。

父类：

public class Animal {//域（成员变量）String name;String sex;int age;String color;//方法（成员方法）public void eat() {System.out.println(name + "吃东西");}
}

子类：

public class Cat extends Animal{//特有的行为（扩展）public void catchMouse() {System.out.println(name+ "抓老鼠...");}//子类可以重写从父类继承而来的方法public void eat() {System.out.println(name+"吃鱼");}
}

Super
Super:指的是当前对象的父类

public class Dog extends Animal {//特有的行为（扩展）public void guard() {System.out.println(name + "看家");}//方法重写  --- 注解@Overridepublic void eat() {super.eat();//调用超类（父类）的eat方法System.out.println(super.name+"啃骨头");//调用超类（父类）的name属性}
}

通过super关键字
1.可以调用父类的成员变量 super.property;
2.可以调用父类的成员方法 super.method();
3.可以调用父类的构造方法 super();

注意：子类默认会调用父类的无参构造，如果显式的调用了父类的有参构造，则不会再调用父类的无参构造。

多态
多态的三个必要条件：
1．继承
2．重写
3．父类引用指向子类对象（上转型对象）

节点4：抽象类和接口

抽象类

定义抽象类：
abstract class Person{
//可以包含抽象方法
}

class Student extends Person{
//子类继承抽象类，要去重写父类的抽象方法。
}

特点：
1.抽象类不一定包含抽象方法，但包含抽象方法的类，一定是抽象类。

抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。
3.抽象类不能实例化。
4.抽象类只能作为子类的超类（父类），被用来创建继承层级里子类的模板。
5.Java中只有单继承。
构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。
抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。
抽象类存在的意义，就是被继承。
接口

语法：
[可见度] interface 接口名称 [extends 其他的接口名] {
// 声明变量
// 抽象方法
}

示例：

/** 1.普通类*  只能包含非抽象方法。*/
public class Student {//属性String name;String sex;int age;//方法public void study() {System.out.println("学习");}
}

/** 2.抽象类*    可以包含抽象方法，非抽象方法，也可以不包含任何方法。*/
public abstract class Animal {//属性String name;//方法public abstract void eat();public void bark() {System.out.println("叫。。。");}
}

/** 3.接口*    只能有抽象方法。*/
public interface Work {//属性(默认用public static final修饰)int count = 0;//注意：接口中的静态常量，一定要赋初值。//方法（默认用public abstract修饰）void work();//抽象方法前的public abstract修饰符可以省略public abstract void earnMoney();
}

接口的实现：

public class Teacher implements Work {@Overridepublic void work() {System.out.println("上课");}@Overridepublic void earnMoney() {System.out.println("拿课时费");}}

特点：
抽象类是一种特殊的类。接口是一种特殊的抽象类。
接口是一个抽象方法的集合。、
Java中，对于类来说，只有单继承，但对于接口来说，可以多继承。
定义接口的关键字：interface
标记接口
标记接口是没有任何方法和属性的接口.它仅仅表明它的类属于一个特定的类型,供其他代码来测试允许做一些事情。
标记接口作用：简单形象的说就是给某个对象打个标（盖个戳），使对象拥有某个或某些特权。
示例：

package java.util;
public interface EventListener {}

节点5：Object类和常用API

Object
Object类是所有类的父类。

常用方法：
（1） hashcode() 返回哈希值
（2） equals() 判断对象是否相等
自动生成方式：在代码中，右键，选择”source”->”Genareate hashcode() and equals()”
（3） getClass() 返回此Object的运行时类。
（4） toString() 返回对象的字符串形式
自动生成方式：在代码中，右键，选择”source”->”Genareate toString() ”

String（不可变性）

创建字符串（构造方法）
（1） String str0 = “Hello”;//字符串常量
（2） String str1 = new String(“Hello”);//通过String构造方法
（3） String str2 = new String(char[] cs);//通过字符数组构造字符串
了解String的11种构造方法
操作字符串（常用方法）
（1） charAt(int index) 返回指定索引处的字符
（2） indexOf(String s) 查找字符在字符串中第一次出现的位置
（3） lastIndexOf(String) 查找字符在字符串中最后一次出现的位置
（4） contains(String s) 判断是否包含字符序列
（5） substring(int beginIndex)
从beginIndex位置截取子字符串，一直扩展到字符串末尾
（6） substring(int beginIndex,int endIndex) [begin,end)
从beginIndex位置截取子字符串，一直到endIndex位置，不包括endIndex.
（7） trim() 去除前后空格！
（8） replace(char oldChar,char newChar) 替换
（9） split(String s) 字符串分割
（10） equals() 判断字符串内容是否相同
（11） equalsIgnoreCase() 忽略大小写判断相等
（12） matches(正则表达式)
（13） length() 返回字符串的字符数（长度）
（14） isEmpty() 判断字符串是否为空字符串
（15） static valueOf(各种数据类型) 返回各种数据类型的字符串形式
（16） toCharArray() 字符串转字符数组
（17） getBytes() 字符串转字节
（18） toLowerCase() 转小写
（19） toUpperCase() 转大写
（20） concat() 字符串拼接 +
（21） format() 格式化字符串 %f %d %s
正则表达式
（1）匹配位置
^ 匹配字符串开始的位置。
$ 匹配字符串结束的位置。
（2）匹配字符
.(点号) 匹配任意一个字符
\ 将下一字符标记为特殊字符
\s 匹配任意空白字符（空格，\f换页符\n换行符\r回车符\t制表符\v垂直制表符）
\S 匹配任意非空白字符
\d 匹配任意数字
\D 匹配非数字
\w 匹配任何字类字符。等价于[A-Za-z0-9_]
\W 匹配任何非字类字符。等价于[^A-Za-z0-9_]
（3）匹配字符范围
x|y 匹配x或y.
[xyz] 匹配包含的任一字符。
[^xyz] 匹配未包含的任一字符。
[a-z] 匹配字符范围。
[^a-z] 匹配反向范围字符
（4）匹配次数
- ```
   匹配前面的字符1-n次
```
- ```
   匹配前面的字符0-n次
```
? 匹配前面的字符0-1次
{n} 匹配前面的字符正好n次
{n,} 匹配前面的字符至少n次
{n,m} 匹配前面的字符至少n次，至多m次。

总结：正则表达式，可以用于匹配matches()，替换replace()和分割split()。
StringBuffer 、StringBuilder
StringBuffer sBuffer = new StringBuffer(“Hello”);
System.out.println(sBuffer);
sBuffer.append(“World!”); //在末尾追加字符 //0123456789
System.out.println(sBuffer); //HelloWorld!
sBuffer.delete(3, 5); //删除多个字符（指定范围） [3,5)
System.out.println(sBuffer); //HelWorld!
sBuffer.deleteCharAt(0);//删除单个字符（指定位置）
System.out.println(sBuffer);//elWorld!
sBuffer.insert(2, “123456”);//在指定位置，插入内容
System.out.println(sBuffer);//el123456World!
sBuffer.reverse();//倒序
System.out.println(sBuffer);
sBuffer.setCharAt(0, ‘A’);//修改指定位置的字符
System.out.println(sBuffer);
StringBuffer中包含很多自己特有方法，也包含一些类似String类中的方法。比如（subString,indexOf,charAt）
StringBuilder和StringBuffer的方法，基本完全相同。

总结：
　　String：适用于少量的字符串操作的情况
　　StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况
　　StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况

日期时间类

Date
Date date = new Date();//获取当前时间
SimpleDateFormat
(1)Date转String
SimpleDateFormat sdf = new SimpleDateFormat(“yyyy年MM月dd日 hh时mm分ss秒 SSS E D”);
String strDate = sdf.format(date);
System.out.println(strDate);
(2)String转Date
String str = “2018年10月01日 10:30:30”;
SimpleDateFormat sdf2 = new SimpleDateFormat(“yyyy年MM月dd日 hh:mm:ss”);
Date date2 = sdf2.parse(str);//异常
System.out.println(date2);

获得系统时间的毫秒数
long start = System.currentTimeMillis( );
long end = date.getTime();

//修改Calendar的时间
//c.set(2009, 6-1, 12);//获取日期的部分信息--年份
System.out.println(c.get(Calendar.YEAR));
System.out.println(c.get(Calendar.MONTH));
System.out.println(c.get(Calendar.DAY_OF_MONTH));System.out.println(c.get(Calendar.DAY_OF_WEEK));System.out.println(c.get(Calendar.HOUR));
System.out.println(c.get(Calendar.HOUR_OF_DAY));//单独设置属性值
c.set(Calendar.YEAR, 2009);c.add(Calendar.YEAR, 5);
c.add(Calendar.MONTH, 2);System.out.println(c.get(Calendar.YEAR));//2014
System.out.println(c.get(Calendar.MONTH));//5//判断闰年
GregorianCalendar gc = new GregorianCalendar();
System.out.println(gc.isLeapYear(1900));

包装类
//包装类（Byte,Short,Integer,Long Float,Double Character Boolean）
//基本数据类型（byte,short,int,long float,double char boolean）

//面向对象编程
int num0 = 10;//数字
Integer num1 = new Integer(20);//对象//Student student = new Student();//封箱（基本数据类型--->包装类）比如：int-->Integer
Integer num2 = new Integer(num0);
Integer num3 = Integer.valueOf(num0);//拆箱（包装类--->基本数据类型）比如：Integer-->int
int num4 = num1.intValue();//自动封箱，拆箱
Integer num6 = 10;
int num5 = new Integer(10);//数值字符串   转成   基本数据类型   例子： "10"  -->  10
String str = "10";
System.out.println(str + 1);
int num7 = Integer.parseInt(str);
System.out.println(num7 + 1);String str2 = "2.5";
System.out.println(str2 + 1);
float f = Float.parseFloat(str2);
System.out.println(f + 1);

数学类
//数学类
System.out.println(Math.E);
System.out.println(Math.PI);

System.out.println(Math.abs(-10.25));//绝对值
System.out.println(Math.sin(Math.PI/6));
System.out.println(Math.cos(Math.PI/3));System.out.println(Math.ceil(2.5));//天花板
System.out.println(Math.floor(2.5));//地板
System.out.println(Math.round(2.26));//近似值System.out.println(Math.sqrt(9));//开平方根
System.out.println(Math.cbrt(8));//开立方根
System.out.println(Math.pow(3, 4));// 求幂System.out.println(Math.max(10, 8));//最大值
System.out.println(Math.min(10, 8));//最小值System.out.println(Math.toDegrees(Math.PI/6));//弧度 转 角度
System.out.println(Math.toRadians(30));//角度 转 弧度System.out.println(Math.random());//随机数   0<=x<1System.out.println(Math.multiplyExact(2, 3));//乘法
System.out.println(Math.negateExact(10));//取反

System和Runtime
System.out.println(“Hello”);
System.err.println(“Hello”);
Scanner sc = new Scanner(System.in);
//系统环境变量
Map<String, String> map = System.getenv();
for (String string : map.keySet()) {
System.out.print(string+"

Java总结-2019.10相关推荐
1. 我叫Java，2019年总结，大家请查收
  大家好!我是你们热爱的Java,2019年过去了,按照惯例,我要做一下年终总结,说说这一年来发生在我身上的大事. 首先我高兴地向大家宣布,我继续在语言排行榜霸占第一的位置 !连续好几年了,真是高处不胜 ...
2. 【附答案】Java面试2019常考题目汇总（一）
  转载自 [附答案]Java面试2019常考题目汇总(一) 一.JAVA基础篇-概念 1.简述你所知道的Linux: Linux起源于1991年,1995年流行起来的免费操作系统,目前, Linux是 ...
3. Java字符串的10大热点问题盘点
  Java字符串的10大热点问题盘点下面我为大家总结了10条Java开发者经常会提的关于Java字符串的问题,如果你也是Java初学者,仔细看看吧: 1.如何比较字符串,应该用"==&quo ...
4. 学java的正确方法_学习Java编程这10个技巧不容错过--中享思途
  这是一个国外大神20多年的经验总结出来的-- "任何可能出错的事情,最后都会出错." 这就是人们为什么喜欢进行"防错性程序设计"的原因.偏执的习惯有时很有意义, ...
5. java书籍_学习Java最好的10本书，从入门到精通
  在当代,学习Java等编程课程的主要方式是视频资源,如果你想学,在网上五分钟之内就可以找到一堆学习视频,瞬间将你的硬盘填满.但是这些课程质量良莠不齐,对于小白来说很难辨别好坏. 但是书籍不同,书籍都是 ...
6. Java 进阶 ——2019 计划要读的书
  Java 进阶 --2019 计划要读的书代码整洁之道重构这两本学习完再写下面的书
7. 野鸡NOI.AC模拟赛【2019.10.26】
  前言截止至2019.10.2614:222019.10.26\ \ \ \ 14:222019.10.26 14:22 成绩正题 T1:NOI.AC−T1:NOI.AC-T1:NOI.AC− ...
8. 小菜：Java异常处理的10个最佳实践
  转载自小菜:Java异常处理的10个最佳实践异常处理在编写健壮的 Java 应用中扮演着非常重要的角色.异常处理并不是功能性需求,它需要优雅地处理任何错误情况,比如资源不可用.非法的输入.nu ...
9. java微妙_编码Java时的10个微妙的最佳实践
  java微妙这是10条最佳实践的列表,这些最佳实践比您的平均Josh Bloch有效Java规则要微妙得多. 尽管Josh Bloch的列表很容易学习,并且涉及日常情况,但此处的列表包含了涉及API ...
最新文章
热门文章

Java总结-2019.10