. 类
Posted wjjgame
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了. 类相关的知识，希望对你有一定的参考价值。
- 9.1 创建和使用类
- 9.1.1 创建 Dog 类
- 9.1.2 根据类创建实例
- 9.2 使用类和实例
- 9.2.1 Car 类
- 9.2.2 给属性指定默认值
- 9.2.3 修改属性的值
- 9.3 继承
- 9.3.1 子类的方法__init__()
- 9.3.2 给子类定义属性和方法
- 9.3.3 重写父类的方法
- 9.3.4 将实例用作属性
- 9.3.5 模拟实物
- 9.4 导入类
- 9.4.1 导入单个类
- 9.4.2 在一个模块中存储多个类
- 9.4.3 从一个模块中导入多个类
- 9.4.4 导入整个模块
- 9.4.5 导入模块中的所有类
- 9.4.6 在一个模块中导入另一个模块
- 9.4.7 使用别名
- 9.4.8 自定义工作流程
- 9.5 Python 标准库
- 9.6 类编码风格
- 9.1.1 创建 Dog 类
根据类来创建对象称为实例化。
根据约定，在 Python 中，首字母大写的名称指的是类。
示例（以下代码这节还不能完全理解）：
class Dog:
"""一次模拟小狗的简单尝试"""
def __init__(self,name,age):
"""初始化属性 name 和 age"""
self.name = name
self.age = age
def sit(self):
"""模拟小狗收到命令时蹲下"""
print(f"self.name is now sitting.")
def roll_over(self):
"""模拟小狗收到命令时打滚"""
print(f"self.name rolled over!")
类中的函数称为方法。 __init()__ 是一个特殊方法，每当你根据 Dog 类创建新实例时，Python 都会自动运行它。在这个方法的名称中，开头和末尾各有两个下划线，这是一种约定。
我们将方法 __init()__ 定义成包含三个形参：self、name和age。在这个方法的定义中，形参 self 必不可少，而且必须位于其他形参的前面。为何必须在方法定义中包含形参 self 呢？因为 Python 调用这个方法来创建 Dog实例时，将自动传入实参 self。每个与实例相关联的方法调用都自动传递实参 self，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。我们通过实参向 Dog() 传递名字和年龄，self 会自动传递，因此不需要传递它。每当根据 Dog 类创建实例时，都只需给最后两个形参（name 和 age）提供值。
self.name 和 self.age 两个变量都有前缀 self。以 self 为前缀的变量可供类中的所有方法使用，可以通过类的任何实例来访问。
Dog 类还定义了另外两个方法：sit() 和 roll_over()。这些方法执行时不需要额外的信息，因此它们只有一个形参 self。
- 9.1.2 根据类创建实例
可将类视为有关如何创建实例的说明。
下面创建一个特定小狗的实例：
class Dog:
--snip--
my_dog = Dog(\'Willie\',6)
print(f"My dog\'s name is my_dog.name.")
print(f"My dog is my_dog.age years old.")
my_dog.sit()
my_dog.roll_over()
res：
访问属性 和 调用方法 都可使用句点表示法。
命名约定很有用：通常可认为首字母大写的名称（如 Dog）指的是类，而小写的名称（如 my_dog）指的是根据类创建的实例。
- 9.2 使用类和实例
可以直接修改实例的属性，也可以编写方法以特定的方式进行修改。
- 9.2.1 Car 类
class Car:
"""一次模拟汽车的简单尝试"""
def __init__(self,make,model,year):
"""初始化描述汽车的属性"""
self.make = make
self.model = model
self.year = year
def get_descriptive_name(self):
"""返回整洁的描述性信息"""
long_name = f"self.year self.make self.model"
return long_name.title()
my_new_car = Car(\'audi\',\'a4\',2019)
print(my_new_car.get_descriptive_name())
res：
（之前没注意到的：当一个字符串中有空格时，再对此字符串使用 title()，那么此字符串的第一个和每个空格后的第一个字符都将大写，其他位置的字符小写）
s1 = "qwe eRT yui"
print(s1.title())
res：
- 9.2.2 给属性指定默认值
创建实例时，有些属性无须通过形参来定义，可在方法 __init()__ 中为其指定默认值。
class Car:
"""一次模拟汽车的简单尝试"""
def __init__(self,make,model,year):
"""初始化描述汽车的属性"""
self.make = make
self.model = model
self.year = year
self.odometer_reading = 0
def get_descriptive_name(self):
"""返回整洁的描述性信息"""
long_name = f"self.year self.make self.model"
return long_name.title()
def read_odometer(self):
"""打印一条指出汽车里程的消息"""
print(f"This car has self.odometer_reading miles on it.")
my_new_car = Car(\'audi\',\'a4\',2019)
print(my_new_car.get_descriptive_name())
my_new_car.read_odometer()
res：
- 9.2.3 修改属性的值
三种方式：直接通过实例进行修改，通过方法进行设置，通过方法进行递增（和前一种差不多）
- 1. 直接修改属性的值
class Car:
--snip--
my_new_car = Car(\'audi\',\'a4\',2019)
print(my_new_car.get_descriptive_name())
my_new_car.odometer_reading = 23
my_new_car.read_odometer()
res:
- 2. 通过方法修改属性的值
class Car:
--snip--
def update_odometer(self,mileage):
"""将里程表读书设置为指定的值"""
self.odometer_reading = mileage
my_new_car = Car(\'audi\',\'a4\',2019)
print(my_new_car.get_descriptive_name())
my_new_car.update_odometer(23)
my_new_car.read_odometer()
res:
- 3. 通过方法对属性的值进行递增
class Car:
--snip--
def update_odometer(self, mileage):
--snip--
def increment_odometer(self,miles):
"""将里程表读数增加指定的量"""
self.odometer_reading += miles
my_new_car = Car(\'audi\',\'a4\',2019)
print(my_new_car.get_descriptive_name())
my_new_car.update_odometer(23_500)
my_new_car.read_odometer()
my_new_car.increment_odometer(100)
my_new_car.read_odometer()
res:
- 9.3 继承
一个类继承另一个类时，将自动获得另一个类的所有属性和方法。
- 9.3.1 子类的方法 __init()__
在既有类的基础上编写新类时，通常要调用父类的方法 __init()__。这将初始化在父类 __init()__ 方法中定义的所有属性，从而让子类包含这些属性。
class Car:
--snip--
class ElectricCar(Car):
"""电动汽车的独特之处"""
def __init__(self,make,model,year):
"""初始化父类的属性"""
super().__init__(make,model,year)
my_tesla = ElectricCar(\'tesla\',\'model s\',2019)
print(my_tesla.get_descriptive_name())
res:
创建子类时，父类必须包含在当前文件中，且位于子类前面。
定义子类时，必须在圆括号内指定父类的名称。方法 __init()__ 接受创建 Car 实例所需的信息。
第 9 行的 super() 是一个特殊函数，让你能够调用父类的方法。这行代码让 Python 调用 Car 类的方法 __init()__ ，让 ElectricCar 实例包含这个方法中定义的所有属性。父类也称为超类( superclass )，名称 super 由此而来。
- 9.3.2 给子类定义属性和方法
class Car:
--snip--
class ElectricCar(Car):
"""电动汽车的独特之处"""
def __init__(self,make,model,year):
"""初始化父类的属性"""
super().__init__(make,model,year)
self.battery_size = 75
def describe_battery(self):
"""打印一条描述电瓶容量的消息"""
print(f"This car has a self.battery_size-kWh battery.")
my_tesla = ElectricCar(\'tesla\',\'model s\',2019)
print(my_tesla.get_descriptive_name())
my_tesla.describe_battery()
res:
根据 EletricCar 类创建的所有实例都将包含属性 battery_size，但所有 Car 实例都不包含它。
- 9.3.3 重写父类的方法
可在子类中定义一个要重写的父类方法同名的方法。这样，Python 将不会考虑这个父类方法，而只关注你在子类中定义的相应方法。
假设 Car 类有一个名为 fill_gas_tank() 的方法，它对全电动汽车来说毫无意义，因此你可能想重写它。下面演示了一种重写方式：
class ElectricCar(Car):
--snip--
def fill_gas_tank(self):
"""电动汽车没有油箱"""
print("This car doesn\'t need a gas tank!")
- 9.3.4 将实例用作属性
class Car:
--snip--
class Battery:
"""一次模拟电动汽车电瓶的简单尝试"""
def __init__(self,battery_size=75):
"""初始化电瓶的属性"""
self.battery_size = battery_size
def describe_battery(self):
"""打印一条描述电瓶容量的消息"""
print(f"This car has a self.battery_size-kWh battery.")
class ElectricCar(Car):
"""电动汽车的独特之处"""
def __init__(self,make,model,year):
"""初始化父类的属性"""
super().__init__(make,model,year)
self.battery = Battery()
my_tesla = ElectricCar(\'tesla\',\'model s\',2019)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()
res:
第 4 行定义了一个新类 Battery，它没有继承任何类。第 7 行的方法 __init()__ 除 self 外，还有另一个形参 battery_size。这个形参是可选的：如果没有给它提供值，电瓶容量将被设置为75。
在 ElectricCar 类中，添加了一个名为 self.battery 的属性。第 21 行代码让 Python 创建一个新的 Battery 实例（因为没有指定容量，所以为默认值 75），并将该实例赋给属性 self.battery。
- 9.4.1 导入单个类
让 Python 打开模块 car.py 并导入其中的 Car 类。
from car import Car
然后直接用导入的类
- 9.4.3 从一个模块中导入多个类
从一个模块中导入多个类时，用逗号分隔了各个类。
从 car.py 导入类 Car 和 ElectricCar
from car import Car, ElectricCar
然后直接用导入的类
- 9.4.4 导入整个模块
可以导入整个模块，再使用句点表示法访问需要的类。
导入整个模块 car
import car
访问语法
module_name.ClassName
- 9.4.5 导入模块中的所有类
from module_name import *
访问语法
module_name.ClassName
- 9.4.7 使用别名
from electric_car import ElectricCar as EC
给 ElectricCar 指定别名 EC
- 9.5 Python 标准库
Python 标准库是一组模块，我们安装的 Python 都包含它。
下面来看看模块 random。
在这个模块中，一个有趣的函数是 randint()。它将两个整数作为参数，并随机返回一个位于这两个整数之间（含）的整数。
另一个有用的函数是 choice()。它将一个列表或元组作为参数，并随机返回其中一个元素。
from random import randint
from random import choice
print(randint(1,6))
players = [\'charles\',\'martina\',\'michael\',\'forence\',\'ali\']
print(choice(players))
res：
- 9.6 类编码风格
类名应采用驼峰命名法，即将类名中的每个单词的首字母都大写，而不使用下划线。实例名和模块名都采用小写格式，并在单词之间加上下划线。
(〃＞＿＜;〃)(〃＞＿＜;〃)(〃＞＿＜;〃)
JavaSE基础六----＜常用类＞Math类Random类|System类,Date类Calendar类SimpleDateFormat类,BigInteger类BigDecimal类
目录
1.Math类
java.lang.Math提供了一系列静态方法用于科学计算；其方法的参数和返回值类型一般为double型。
部分方法
- abs( ) 返回绝对值
- PI 返回π值
- sqrt( ) 平方根
- pow(double a, double b) a的b次幂
- ceil( ) 向上取整
- floor( ) 向下取整
- max(int a,int b) 返回最大值
- random( ) 返回 0.0 到 1.0 的随机数
- long round(double a) double型的数据a转换为long型（四舍五入）
//Math类
public class Demo001 {
public static void main(String[] args) {
// abs() 返回绝对值
System.out.println(Math.abs(-56));//56
//PI 返回π值
System.out.println(Math.PI);//3.141592653589793
// sqrt() 平方根
System.out.println(Math.sqrt(9.0));//3.0
// pow(double a, double b) a的b次幂
System.out.println(Math.pow(3,2));//9.0
//ceil() 向上取整
System.out.println(Math.ceil(65.5));//66.0
//floor()向下取整
System.out.println(Math.floor(65.5));//65.0
// max(int a,int b) 返回最大值
System.out.println(Math.max(10,36));//36
// random( ) 返回 0.0 到 1.0 的随机数
System.out.println(Math.random());//0.7877114246802791
// long round(double a) double型的数据a转换为long型（四舍五入）
System.out.println(Math.round(25.6));//26
}
}
2.Random类
java.util.Random
产生随机数的类
- public boolean nextBoolean()
随机生成true/false - public int nextInt( )
随机生成int范围内的一个数 - public int nextInt(@Range(from = 1, to = Integer.MAX_VALUE) int bound)
随机生成一个范围内的数字 - public void nextBytes(byte[] bytes)
随机生成一个数组
import java.util.Arrays;
import java.util.Random;
//Random类
//生成随机数
public class Demo001 {
public static void main(String[] args) {
//先创建对象
Random r=new Random();
//public boolean nextBoolean()
//随机生成true/false
System.out.println(r.nextBoolean());//true
//public int nextInt()
//随机生成int范围内的一个数
System.out.println(r.nextInt());//1236471934
//public int nextInt(@Range(from = 1, to = Integer.MAX_VALUE) int bound)
//随机生成一个范围内的数字
System.out.println(r.nextInt(20));//15
//public void nextBytes(byte[] bytes)
//随机生成一个数组
byte[] array=new byte[10];
r.nextBytes(array);
System.out.println(Arrays.toString(array));
//[-80, 61, -61, 23, 108, -40, 98, -61, -103, 74]
}
}
3.System类
java.lang.System
System类包含几个有用的类字段和方法。 它不能被实例化。
System类提供的System包括标准输入，标准输出和错误输出流; 访问外部定义的属性和环境变量; 一种加载文件和库的方法; 以及用于快速复制阵列的一部分的实用方法。
-public static void exit(int status)
关闭程序,让虚拟机停止
public class Demo001 {
public static void main(String[] args) {
//public static void exit(int status)
//关闭程序,让虚拟机停止
System.exit(0);
//后面的程序不再执行
System.out.println("123");
}
}
- public static long currentTimeMillis()
获得当前时间,返回毫秒值;
时间的表达格式为当前计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数。
实际应用中,可用于测试程序的运行时间;
public class Demo002 {
public static void main(String[] args) {
//public static long currentTimeMillis()
//获得当前时间,返回毫秒值
//时间的表达格式为当前计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数。
System.out.println(System.currentTimeMillis());//1619946068342
}
}
- public static void arraycopy(@NotNull Object src,int srcPos,@NotNull Object dest,int destPos,int length)
src:原数组,srcpos:从原数组的第几个下标位置开始;
desc:复制到的目标数组; descpos:目标数组的第几个下标位置开始传入;
length:复制的数组长度
import java.util.Arrays;
public class Demo003 {
public static void main(String[] args) {
//public static void arraycopy(@NotNull Object src,int srcPos,@NotNull Object dest,int destPos,int length)
//src:原数组,srcpos:从原数组的第几个下标位置开始;
//desc:复制到的目标数组; descpos:目标数组的第几个下标位置开始传入;
//length:复制的数组长度
//原数组a
int[] a={1,4,3,5,2,7,1,3};
//目标数组b
int[] b=new int[10];
//从数组a的第0个下标位置开始,复制5个元素,到数组b的第2个下标位置开始;
System.arraycopy(a,0,b,2,5);
//输出数组b
System.out.println(Arrays.toString(b));
//[0, 0, 1, 4, 3, 5, 2, 0, 0, 0]
}
}
4.Date类/Calendar类/ SimpleDateFormat类
Date类
代表当前系统时间;
构造方法:
- 有参构造:public Date(long date)
import java.util.Date;
public class Demo001 {
public static void main(String[] args) {
//有参构造;
// 传入Long类型的时间(时间的表达格式为那一刻的计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数。)
//public Date(long date)
Date d=new Date(1619946068342L);
//输出为那一刻的时间
System.out.println(d);
//Sun May 02 17:01:08 CST 2021
}
}
- 无参构造:public Date( )
import java.util.Date;
public class Demo002 {
public static void main(String[] args) {
//无参构造:public Date()
Date d=new Date();
//返回当前计算机时间
System.out.println(d);
//Sun May 02 17:44:32 CST 2021
}
}
几个方法:(部分方法已过期)
获取时间的方法:
-
public int getYear( );获取年份,(方法的底层是减去了1900的,所以要加1900得到真实的年份)
-
public int getMonth( );获取月份;注意月份是从零开始的,
-
public int getDate( );得到这个月的第几天
-
public int getDay( );这周的第几天获取星期几;也是从0开始的;
0(星期天),1(周一),2,3,4,5,6, -
public long getTime( )
返回long类型的毫秒值;和System类中获取的时间是一样的
import java.util.Date;
public class Demo002 {
public static void main(String[] args) {
//无参构造:public Date()
Date d=new Date();
//返回当前计算机时间
System.out.println(d);
//Sun May 02 17:44:32 CST 2021
//public int getYear();获取年份
System.out.println(d.getYear()+1900);//2021
//public int getMonth();获取月份;注意月份是从零开始的,
System.out.println(d.getMonth()+1);//5
//public int getDay();获取星期几;也是从0开始的
//0(星期天),1(周一),2,3,4,5,6,
System.out.println(d.getDay());//0
//public long getTime()
//返回long类型的毫秒值;和System类中获取的时间是一样的
System.out.println(d.getTime());//1619949019785
}
}
设置时间方法:
-
public void setYear(int year)
设置年份 -
public void setMonth(int month)
设置月份 -
public void setTime(long time)
设置时间,传入long类型的毫秒值;
import java.util.Date;
public class Demo008 {
public static void main(String[] args) {
//设置时间的方法
Date d2=new Date();
//public void setYear(int year)
//设置年份
d2.setYear(2015);
//获取年份
System.out.println(d2.getYear());//2015
//public void setMonth(int month)
//设置月份
d2.setMonth(6);
System.out.println(d2.getMonth());//6
//public void setTime(long time)
//设置时间,传入long类型的毫秒值;
d2.setTime(1619949019785L);
System.out.println(d2.getYear()+1900);//2021
}
}
Calendar类
public abstract class Calendar
所述Calendar类是一个抽象类，可以为在某一特定时刻和一组之间的转换的方法calendar fields如YEAR ， MONTH ， DAY_OF_MONTH ， HOUR ，等等，以及用于操纵该日历字段，如获取的日期下个星期。 时间上的瞬间可以用毫秒值表示，该值是从1970年1月1日00:00 00：00.000 GMT（Gregorian）的Epoch的偏移量。
Calendar提供了一种类方法getInstance ，用于获取此类型的一般有用的对象。 Calendar的getInstance方法返回一个Calendar对象，其日历字段已使用当前日期和时间进行初始化：
Calendar rightNow = Calendar.getInstance( );
由于它的输出时间是GregorianCalendar类的,所以也可以直接new 一个GregorianCalendar( );
import java.util.Calendar;
import java.util.GregorianCalendar;
//Calendar类的使用
public class Demo001 {
public static void main(String[] args) {
// Calendar rightNow = Calendar.getInstance();
Calendar rightNow=new GregorianCalendar();
System.out.println(rightNow);
}
}
输出当前时间:
java.util.GregorianCalendar[time=1619951333463,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=31,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2021,MONTH=4,WEEK_OF_YEAR=19,WEEK_OF_MONTH=2,DAY_OF_MONTH=2,DAY_OF_YEAR=122,DAY_OF_WEEK=1,DAY_OF_WEEK_IN_MONTH=1,AM_PM=1,HOUR=6,HOUR_OF_DAY=18,MINUTE=28,SECOND=53,MILLISECOND=463,ZONE_OFFSET=28800000,DST_OFFSET=0]
其中包含的一些日期字段,可以直接去通过Calendar调用:
// Calendar rightNow = Calendar.getInstance();
Calendar rightNow=new GregorianCalendar();
System.out.println(rightNow);
//获取年份
System.out.println(rightNow.get(Calendar.YEAR));//2021
//获取这个月的第几天
System.out.println(rightNow.get(Calendar.DAY_OF_MONTH));//2
//获取月份,月份是从0开始的
System.out.println(rightNow.get(Calendar.MONTH));//4
也有一部分方法可以被引用变量rightNow直接调用的;
//public final java.util.Date getTime()
//注意用的是Date类的方法,获取计算机时间
System.out.println(rightNow.getTime());//Sun May 02 18:38:54 CST 2021
//public long getTimeInMillis()
//获取毫秒值时间
System.out.println(rightNow.getTimeInMillis());//1619952005857
//public final void set(int year,int month,int date)
//设置时间
rightNow.set(2021,5,8);
SimpleDateFormat类
日期格式化类;
SimpleDateFormat是一个具体的类，用于以区域设置的方式格式化和解析日期。 它允许格式化（日期文本），解析（文本日期）和归一化。
日期和时间格式由日期和时间模式字符串指定。
- 日期对象转化为指定格式的字符串;
public final String format(java.util.Date date)
import java.text.SimpleDateFormat;
import java.util.Date;
//SimpleDateFormat类的使用
//日期格式化
public class Demo001 {
public static void main(String[] args) {
//日期对象转化为指定格式的字符串
//这里新建了一个Date对象
Date d=new Date();
//新建simpleDateFormat对象
//在其中写入将要显示的格式,后面还可以加入国家来匹配语言;
SimpleDateFormat sdf=new SimpleDateFormat("yyyy年/MM月/dd日 (E) HH时mm分ss秒 ");
//public final String format(java.util.Date date)
//日期对象转为字符串
String s=sdf.format(d);
System.out.println(s);//2021年/05月/02日 (星期日) 19时00分35秒
}
}
- 指定格式的字符串转为日期对象
public java.util.Date parse(String source)
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Demo002 {
public static void main(String[] args) {
//指定格式的字符串转为日期对象
String s1=" 2001-2-2 13:13:13 星期五";
//新建simpleDateFormat对象;写上字符串对应的格式
SimpleDateFormat sdf1=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss E");
//public java.util.Date parse(String source)
//将字符串转化为Date对象
//此处需要try,catch处理ParseException
try {
Date d1=sdf1.parse(s1);
System.out.println(d1);//Fri Feb 02 13:13:13 CST 2001
} catch (ParseException e) {
e.printStackTrace();
}
}
}
5.BigInteger类
不可变的任意精度整数。位于java.math包中
在 Java 中，有许多数字处理的类，比如 Integer类，但是Integer类有一定的局限性。Integer 是 Int 的包装类，int 的最大值为 2^31-1。若希望描述更大的整数数据时，使用Integer 数据类型就无法实现了，所以Java中提供了BigInteger 类。BigInteger类型的数字范围较Integer，Long类型的数字范围要大得多，它支持任意精度的整数，也就是说在运算中 BigInteger 类型可以准确地表示任何大小的整数值而不会丢失任何信息。
构造方法
几个基本方法
- public BigInteger add(BigInteger val)
加法 - public BigInteger subtract(BigInteger val)
减法 - public BigInteger multiply(BigInteger val)
乘法 - public BigInteger divide(BigInteger val)
除法
6.BigDecimal类
在计算机中不论是float 还是double都是浮点数，而计算机是二进制的，浮点数会失去一定的精确度。根本原因是十进制值通常没有完全相同的二进制表示形式;十进制数的二进制表示形式可能不精确。只能无限接近于那个值;
这时就需要用到BigDecimal类;可以达到精确计算;避免精度损失;
BigDecimal类提供了算术，缩放操作，舍入，比较，散列和格式转换的操作。
构造方法:
同样的,它也可以传入各种参数;
基本的算术方法;
需要注意的是;在除法运算过程中;有除不尽的状况出现时,可以选择使用方法,进行保留几位小数,以及是否四舍五入;
import java.math.BigDecimal;
//BigDicemal类
//浮点类型的精确计算
public class Demo001 {
public static void main(String[] args) {
BigDecimal a=new BigDecimal("20");
BigDecimal b=new BigDecimal("3");
//public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)
//scale为5, 则保留5位小数,BigDecimal.ROUND_HALF_UP:四舍五入;
System.out.println(a.divide(b,5,BigDecimal.ROUND_HALF_UP));//6.66667
//scale为8, 则保留8位小数,BigDecimal.ROUND_FLOOR:不进行四舍五入;
System.out.println(a.divide(b,8,BigDecimal.ROUND_FLOOR));//6.66666666
}
}
常用类(1)(2)
常用类总结笔记
以上是关于. 类的主要内容，如果未能解决你的问题，请参考以下文章
JavaSE基础(十 三 )---＜内部类＞成员内部类,静态内部类,局部内部类,匿名内部类,内部类的意义