类：我说现在已经开始公布HUAWEI手机 P50的概念机，那就是说这款手机还没有实体机存在，只是官方还在设计这个手机。　　　　　　其中包含：颜色、尺寸、分辨率等。以上说的是这款概念机中的属性、　　　　　　另还包含：上网、打电话、发短信、拍照、看电视等。这是在说的是这款概念机所具有的功能，也就是行为！对象：我说现在已经开始公布HUAWEI手机 P30的实体机，那就是说这款手机已经存在实体机。但是有这款手机之前，也一定会先有该机的设计图或是概念机。

3. 成员变量和局部变量区别

定义类：就是定义类的成员，包括成员变量和成员方法。
成员变量：和以前定义变量几乎是一样的。只不过位置发生了改变。在类中，方法外。
成员方法：和以前定义方法几乎是一样的。只不过把static去掉，static的作用在面向对象后面中再详细讲解。

接下来通过一幅图来认识一下成员和局部

在类中的位置不同【重点】
- 成员变量：类中，方法外
- 局部变量：方法中或者方法声明上(形式参数)
作用范围不一样【重点】
- 成员变量：类中
- 局部变量：方法中
初始化值的不同【重点】
- 成员变量：有默认值
- 局部变量：没有默认值。必须先定义，赋值，最后使用
在内存中的位置不同【重点】
- 成员变量：堆内存
- 局部变量：栈内存
生命周期不同【重点】
- 成员变量：随着对象的创建而存在，随着对象的消失而消失
- 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

4. 数据类型

Java的数据类型划分为两大类：基础数据类型和引用数据类型

5.构造函数

定义格式：

权限修饰符 构造方法名(参数列表){

    // 方法体 

}

构造方法的写法上，方法名与它所在的类名相同。它没有返回值，所以不需要返回值类型，甚至不需要void。

如果你不提供构造方法，系统会给出无参数构造方法。
如果你提供了构造方法，系统将不再提供无参数构造方法。
构造方法是可以重载的，既可以定义参数，也可以不定义参数

6.函数

函数定义格式：

权限修饰符 [修饰符] 返回值类型 方法名(参数列表){
    //代码省略...
    return 结果;
}

// 上方用方括号包括的修饰符可以有、也可以没有。
// 修饰符有抽象修饰符abstract、有静态修饰符static、也有线程同步锁方法 synchronized 等。

修饰符： public static 固定写法
返回值类型：表示方法运行的结果的数据类型，方法执行后将结果返回到调用者
参数列表：方法在运算过程中的未知数据，调用者调用方法时传递
return：将方法执行后的结果带给调用者，方法执行到 return ，整体方法运行结束
- 注意: 不能在 return 后面写代码， return 意味着方法结束，所有后面的代码永远不会执行，属于无效代码。
- 注意: 返回值类型，必须要和 return 语句返回的类型相同，否则编译失败

如何定义方法

首先要确定返回值类型和参数列表

调用方法的流程图解

函数重载

方法重载：指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符和返回值类型无关。
参数列表：个数不同，数据类型不同，顺序不同。
重载方法调用：JVM通过方法的参数列表，调用不同的方法。

7. 成员变量的初始化

	数据类型	默认值
基础数据类型	整型【byte,short,int,long】	0
	浮点型【float,double】	0.0
	字符【char】	'\u0000'
	布尔【boolean】	false
引用数据类型	数组、类、接口	null

8. this关键字

我们发现 setXxx 方法中的形参名字并不符合见名知意的规定，那么如果修改与成员变量名一致，是否就见名知意了呢？代码如下：

public class Student {
    private String name;
    private int age;
    
    public void setName(String name) {
    	name = name;
    }
    public void setAge(int age) {
    	age = age;
    }
}

经过修改和测试，我们发现新的问题，成员变量赋值失败了。也就是说，在修改了 setXxx() 的形参变量名后，方法并没有给成员变量赋值！这是由于形参变量名与成员变量名重名，导致成员变量名被隐藏，方法中的变量名，无法访问到成员变量，从而赋值失败。所以，我们只能使用this关键字，来解决这个重名问题。

this代表的是当前类对象。

9. static关键字

概述

关于 static 关键字的使用，它可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属于某个对象的。

也就是说，既然属于类，就可以不靠创建对象来调用了。

9.1 静态成员变量、静态成员变量初始化

静态成员变量：

当 static 修饰成员变量时，该变量称为类变量。

该类的每个对象都共享同一个类变量的值。

任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。

静态成员变量初始化

静态成员只会在每个类中初始化一次【静态对象(变量)只初始化一次,而非静态对象(变量)可能会初始化多次】

【Java笔试题】：构造方法、成员变量初始化以及静态成员变量初始化三者的先后顺序是什么样的？

答：先后顺序是：静态成员变量、成员变量、构造方法。

原因：

a. 当类第一次被加载的时候,静态变量会首先初始化,接着编译器会把实例变量初始化为默认值,然后执行构造方法。

b. Java程序的初始化一般遵循以下三个原则(以下三原则优先级依次递减):

① 静态对象(变量)优先于非静态对象(变量)初始化,其中,静态对象(变量)只初始化一次,而非静态对象(变量)可能会初始化多次；

② 父类优先于子类进行初始化；

③ 按照成员变量定义顺序进行初始化,即使变量定义散布于方法定义中,它们依然在任何方法(包括构造方法)被调用之前先初始化。

9.2 静态成员方法

当 static 修饰成员方法时，该方法称为类方法。
静态方法在声明中有 static ，建议使用类名来调用，而不需要创建类的对象。
调用方式非常简单。

10. JVM对象内存结构

Java中的内存分配：

Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对数据进行了不同空间的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

具体划分为如下5个内存空间：

栈：存放局部变量
堆：存放所有new出来的东西
方法区：被虚拟机加载的类信息、常量、静态常量等。
寄存器(和系统CPU相关)
本地方法区

11. Java 继承

概述：

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那一个类即可。

如图所示：

其中，多个类可以称为子类，单独那一个类称为父类、超类（superclass）或者基类。继承描述的是事物之间的所属关系，这种关系是： is-a 的关系。例如，图中兔子属于食草动物，食草动物属于动物。可见，父类更通用，子类更具体。我们通过继承，可以使多种事物之间形成一种关系体系。

定义：

继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。

子类可以直接访问父类中的非私有的属性和行为。

好处:

1. 提高代码的复用性。

2. 类与类之间产生了关系，继承是多态的前提。

继承的格式:

通过 extends 关键字，可以声明一个子类继承另外一个父类，定义格式如下：

class 父类 {
...
}
class 子类 extends 父类 {
...
}

继承演示，代码如下：

/*
 * 定义员工类Employee，做为父类
 */
class Employee {
    String name; // 定义name属性
    // 定义员工的工作方法
    public void work() {
        System.out.println("尽心尽力地工作");
    }
}

/*
 * 定义讲师类Teacher 继承 员工类Employee
 */
class Teacher extends Employee {
    // 定义一个打印name的方法
    public void printName() {
    System.out.println("name=" + name);
    }
}

/*
 * 定义测试类
 */
public class ExtendDemo01 {
    public static void main(String[] args) {
        // 创建一个讲师类对象
        Teacher t = new Teacher();
        // 为该员工类的name属性进行赋值
        t.name = "小明";
        // 调用该员工的printName()方法
        t.printName(); // name = 小明
        // 调用Teacher类继承来的work()方法
        t.work(); // 尽心尽力地工作
    }
}

12. 继承中的构造方法

当类之间产生了关系，其中各类中的构造方法，又产生了哪些影响呢？

首先我们要回忆两个事情，构造方法的定义格式和作用。

1. 构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。

2. 构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。

子类的构造方法中默认有一个 super() ，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。

代码如下

class Aminal {

    private int age;

    Aminal() {
        System.out.println(age);
    }
}

class Dog extends Aminal {
    // 不写 super(); Jvm 也会调用执行super();

    Dog() {
        System.out.println("wangcai");
    }
}

public class TestExtendsDemo {

    public static void main(String[] args) {
        Dog dog = new Dog();
    }
}

// 打印出结果是：0        wangcai

super和this的含义

super ：代表父类的存储空间标识(可以理解为父亲的引用)。

this ：代表当前对象的引用(谁调用就代表谁)。

子类的每个构造方法中均有默认的super()，调用父类的空参构造。
手动调用父类构造会覆盖默认的super()。
super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现

13. InstanceOf关键字

instanceof关键字 1:用于判断某个对象是否是某种类型。 2:格式对象名 instanceof 子类(实现)名

14.动态Bingding

动态绑定（后期绑定）是指：在程序运行过程中，根据具体的实例对象才能具体确定是哪个方法。

15.方法重写

16.Object类API

java.lang.Object类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。在对象实例化的时候，最终找的父类就是Object。

如果一个类没有特别指定父类，那么默认则继承自Object类

根据JDK源代码及Object类的API文档，Object类当中包含的方法有11个。今天我们主要学习其中的2个：

public String toString()：返回该对象的字符串表示。
public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。

toString方法

public String toString()：返回该对象的字符串表示。

toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。

由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。

equals方法

public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。

调用成员方法equals并指定参数为另一个对象，则可以判断这两个对象是否是相同的。

这里的“相同”有默认和自定义两种方式。

17. 访问控制（包、访问权限）

18. final关键字

学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。那么我们能不能随意的继承 API中提供的类，改写其内容呢？显然这是不合适的。为了避免这种随意改写的情况，Java提供了 final 关键字，用于修饰不可改变内容。

final： 不可改变。可以用于修饰类、方法和变量
- 类：被修饰的类，不能被继承。
- 方法：被修饰的方法，不能被重写。
- 变量：被修饰的变量，不能被重新赋值。

使用方式：

修饰类
- 格式如下

final class 类名 {
}

通过查询API回发现像 public final class String 、 public final class Math 、 public final class Scanner 等，很多我们学习过的类，都是被final修饰的，目的就是供我们使用，而不让我们所以改变其内容

修饰方法
- 格式如下

修饰符 final 返回值类型 方法名(参数列表){
//方法体
}

修饰变量 基本类型的局部变量，被final修饰后，只能赋值一次，不能再更改。代码如下
- 局部变量——基本类型
- 局部变量——引用类型

19. 抽象类

20. 接口

21. 内部类

22.String和StringBuffer

String类:

查看类
- java.lang.String ：此类不需要导入。
查看构造方法
- public String() ：初始化新创建的 String对象，以使其表示空字符序列。
- public String(char[] value) ：通过当前参数中的字符数组来构造新的String。
- public String(byte[] bytes) ：通过使用平台的默认字符集解码当前参数中的字节数组来构造新的 String。
构造举例，代码如下：

// 无参构造
String str = new String（）；
// 通过字符数组构造
char chars[] = {'H', 'e', 'l', 'l', 'o'};
String str2 = new String(chars);
// 通过字节数组构造
byte bytes[] = { 66, 88, 108 };// 注意： 这里数字范围是 { -128 ~ 127，包括0}
String str3 = new String(bytes);

常用方法:

判断功能的方法
- public boolean equals (Object anObject) ：将此字符串与指定对象进行比较。
- public boolean equalsIgnoreCase (String anotherString) ：将此字符串与指定对象进行比较，忽略大小写。
- public boolean contains(CharSequence s):该方法是判断字符串中是否有子字符串。如果有则返回true，如果没有则返回false。

public class Demo {
    public static void main(String[] args) {
        // 创建字符串对象
        String s1 = "hello";
        String s2 = "hello";
        String s3 = "HELLO";
        // boolean equals(Object obj):比较字符串的内容是否相同
        System.out.println(s1.equals(s2)); // true
        System.out.println(s1.equals(s3)); // false
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
        //boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
        System.out.println(s1.equalsIgnoreCase(s2)); // true
        System.out.println(s1.equalsIgnoreCase(s3)); // true
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
        //boolean contains(CharSequence s):该方法是判断字符串中是否有子字符串。如果有则返回true，如果没有则返回false。
        System.out.println(s1.contains("-"));   // false
        System.out.println(s2.contains("l"));  // true
        System.out.println(s2.contains("he")) ;// true
        System.out.println(s2.contains("hl")); // false
        System.out.println(s3.contains("."));  // false
    }
}

获取功能的方法
- public int length () ：返回此字符串的长度。
- public String concat (String str) ：将指定的字符串连接到该字符串的末尾。
- public char charAt (int index) ：返回指定索引处的 char值。
- public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。
- public int lastIndexOf (String str) ：返回指定子字符串最后一次出现在该字符串内的索引。
- public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
- public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到 endIndex截取字符串。含beginIndex，不含endIndex。[包头不包尾]

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

//创建字符串对象
            String s = "helloworld";
// int length():获取字符串的长度，其实也就是字符个数
            System.out.println("字符串s的长度是：" + s.length());// 10
            System.out.println("‐‐‐‐‐‐‐‐");
// String concat (String str):将将指定的字符串连接到该字符串的末尾.
            String s1 = "helloworld";
            String s2 = s1.concat("**Cheer HuaWei");
            System.out.println(s2);// helloworld**Cheer HuaWei
// char charAt(int index):获取指定索引处的字符
            System.out.println(s.charAt(0));
            System.out.println(s.charAt(1));
            System.out.println("‐‐‐‐‐‐‐‐");
// int indexOf(String str):获取str在字符串对象中第一次出现的索引,没有返回‐1
            System.out.println(s1.indexOf("l"));
            System.out.println(s1.indexOf("owo"));
            System.out.println(s1.indexOf("ak"));
            System.out.println("‐‐‐‐‐‐‐‐");
// int lastIndexOf(String str):获取str在字符串对象中最后一次出现的索引,没有返回‐1
            System.out.println(s1.indexOf("l"));
            System.out.println(s1.indexOf("owo"));
            System.out.println(s1.indexOf("ak"));
            System.out.println("‐‐‐‐‐‐‐‐");
// String substring(int start):从start开始截取字符串到字符串结尾
            System.out.println(s.substring(0));
            System.out.println(s.substring(5));
            System.out.println("‐‐‐‐‐‐‐‐");
// String substring(int start,int end):从start到end截取字符串。含start，不含end。
            System.out.println(s.substring(0, s.length()));
            System.out.println(s.substring(3,8));
        }

        }
}

转换功能的方法
- public char[] toCharArray () ：将此字符串转换为新的字符数组。
- public byte[] getBytes () ：使用平台的默认字符集将该 String编码转换为新的字节数组。
- public String replace (CharSequence target, CharSequence replacement) ：将与target匹配的字符串使用replacement字符串替换。

public class Demo {

    public static void main(String[] args) {
        //创建字符串对象
        String s = "abcde";
// char[] toCharArray():把字符串转换为字符数组
        char[] chs = s.toCharArray();
        for (int x = 0; x < chs.length; x++) {
            System.out.println(chs[x]);
        }
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
// byte[] getBytes ():把字符串转换为字节数组
        byte[] bytes = s.getBytes();
        for (int x = 0; x < bytes.length; x++) {
            System.out.println(bytes[x]);
        }
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
// 替换字母huawei为大写HuaWei
        String str = "Cheer huawei";
        String replace = str.replace("huawei", "HuaWei");
        System.out.println(replace); // Cheer HuaWei
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
    }

}

分割功能的方法
- public String[] split(String regex) ：将此字符串按照给定的regex（规则）拆分为字符串数组。

public class Demo {

    public static void main(String[] args) {
        //创建字符串对象
        String s = "forward:index";
        String[] strArray = s.split(":"); // ["forward","index"]
        System.out.println(strArray.length);// 2
        for(int x = 0; x < strArray.length; x++) {
            System.out.print(strArray[x] + " "); // forward index 
        }
    }
}

StringBuilder类

查阅java.lang.StringBuilder的API，StringBuilder又称为可变字符序列，它是一个类似于 String 的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容。
原来StringBuilder是个字符串的缓冲区，即它是一个容器，容器中可以装很多字符串。并且能够对其中的字符串进行各种操作。
它的内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容。StringBuilder会自动维护数组的扩容。原理如下图所示：(默认16字符空间，超过自动扩充)
StringBuilder已经覆盖重写了Object当中的toString方法。

构造方法：

public StringBuilder()：构造一个空的StringBuilder容器。
public StringBuilder(String str)：构造一个StringBuilder容器，并将字符串添加进去。

public class StringBuilderDemo {
    public static void main(String[] args) {
        StringBuilder sb1 = new StringBuilder();
        System.out.println(sb1); // (空白)
        // 使用带参构造
        StringBuilder sb2 = new StringBuilder("you");
        System.out.println(sb2); // you
    }
}

常用方法：

public StringBuilder append(...)：添加任意类型数据的字符串形式，并返回当前对象自身。
public String toString()：将当前StringBuilder对象转换为String对象

分别介绍两个方法：

append方法
- append方法具有多种重载形式，可以接收任意类型的参数。
- 任何数据作为参数都会将对应的字符串内容添加到StringBuilder中。

public class StringBuilderDemo {
	public static void main(String[] args) {
		//创建对象
		StringBuilder builder = new StringBuilder();
		//public StringBuilder append(任意类型)
		StringBuilder builder2 = builder.append("hello");
		//对比一下
		System.out.println("builder:"+builder);
		System.out.println("builder2:"+builder2);
		System.out.println(builder == builder2); //true
	    // 可以添加 任何类型
		builder.append("hello");
		builder.append("world");
		builder.append(true);
		builder.append(100);
		// 在我们开发中，会遇到调用一个方法后，返回一个对象的情况。然后使用返回的对象继续调用方法。
        // 这种时候，我们就可以把代码现在一起，如append方法一样，代码如下
		//链式编程
		builder.append("hello").append("world").append(true).append(100);
		System.out.println("builder:"+builder);
	}
}

toString方法
- 通过toString方法，StringBuilder对象将会转换为不可变的String对象

public class StringBuilderDemo {
    public static void main(String[] args) {
        // 链式创建
        StringBuilder sb = new StringBuilder("Hello").append("World").append("Java");
        // 调用方法
        String str = sb.toString();
        System.out.println(str); // HelloWorldJava
    }
}

23.正则表达式

24.System和Runtime类

System类

java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作，在System类的API文档中，常用的方法有：

public static long currentTimeMillis()：返回以毫秒为单位的当前时间。
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将数组中指定的数据拷贝到另一个数组中。

currentTimeMillis方法

实际上，currentTimeMillis方法就是获取当前系统时间与1970年01月01日00:00点之间的毫秒差值

public class Demo {

    public static void main(String[] args) throws ParseException {
        //获取当前时间毫秒值
        System.out.println(System.currentTimeMillis()); // 1562038452052
    }
}

public class Demo {

    /*
        需求： 验证for循环打印数字1-9999所需要使用的时间（毫秒）
     */
    public static void main(String[] args) throws ParseException {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("共耗时毫秒：" + (end - start));
    }
}

Runtime类

25.Date和DateFormat类

Date类

`java.util.Date`类表示特定的瞬间，精确到毫秒

继续查阅Date类的描述，发现Date拥有多个构造函数，只是部分已经过时，但是其中有未过时的构造函数可以把毫秒值转成日期对象。

public Date()：分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
public Date(long date)：分配Date对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即1970年1月1日00:00:00 GMT）以来的指定毫秒数。

提醒：我们处于东八区，所以我们的基准时间为1970年1月1日8时0分0秒。

通俗来说：使用无参构造，可以自动设置当前系统时间的毫秒时刻；指定long类型的构造参数，可以自定义毫秒时刻。

例如

import java.util.Date;

/*
 * 注意：
 *  在使用println方法时，会自动调用Date类中的toString方法。
 *  Date类对Object类中的toString方法进行了覆盖重写，所以结果为指定格式的字符串
 */
public class Demo {

    public static void main(String[] args) {
        // 创建日期对象，把当前的时间
        System.out.println(new Date()); // Tue Jul 02 11:22:10 CST 2019
        // 创建日期对象，把当前的毫秒值转成日期对象
        System.out.println(new Date(0L)); // Thu Jan 01 08:00:00 CST 1970
    }
}

DateFormat类

java.text.DateFormat 是日期/时间格式化子类的抽象类，我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以在Date对象与String对象之间进行来回转换。

格式化：按照指定的格式，从Date对象转换为String对象。
解析：按照指定的格式，从String对象转换为Date对象。

构造方法：

由于DateFormat为抽象类，不能直接使用，所以需要常用的子类java.text.SimpleDateFormat。

这个类需要一个模式（格式）来指定格式化或解析的标准。构造方法为：

public SimpleDateFormat(String pattern)：用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。
- 参数pattern是一个字符串，代表日期时间的自定义格式。

格式规则

常用的格式规则为：

标识字母（区分大小写）	文字描述含义
y	年
M	月
d	日
H	时
m	分
s	秒

示例代码：

public class Demo {

    public static void main(String[] args) {
        // 对应的日期格式如：2019-07-02 11:28:29
        DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println(format.format(new Date()));// 输出结果：2019-07-02 11:28:29
    }
}

常用方法:

DateFormat类的常用方法有：

public String format(Date date)：将Date对象格式化为字符串。
public Date parse(String source)：将字符串解析为Date对象。

26.Math等其它常用类介绍

java.lang.Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单。

基本运算的方法：

public static double abs(double a) ：返回 double 值的绝对值

double d1 = Math.abs(‐2); //d1的值为2
double d2 = Math.abs(2); //d2的值为2

public static double ceil(double a) ：返回大于等于参数的最小的整数。

double d1 = Math.ceil(3.3); //d1的值为 4.0
double d2 = Math.ceil(‐3.3); //d2的值为 ‐3.0
double d3 = Math.ceil(5.1); //d3的值为 6.0

public static double floor(double a) ：返回小于等于参数最大的整数

double d1 = Math.floor(3.3); //d1的值为3.0
double d2 = Math.floor(‐3.3); //d2的值为‐4.0
double d3 = Math.floor(5.1); //d3的值为 5.0

public static long round(double a) ：返回最接近参数的 long。(相当于四舍五入方法)

long d1 = Math.round(5.5); //d1的值为6.0
long d2 = Math.round(5.4); //d2的值为5.0

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2019年07月03日，如有侵权请联系 cloudcommunity@tencent.com 删除

java

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

java