在Java中提供了四种访问权限,使用不同的访问权限修饰符修饰时,被修饰的内容会有不同的访问权限,
第一章 权限修饰符
知识点--权限修饰符
目标:
路径:
讲解:
3.1 概述
在Java中提供了四种访问权限,使用不同的访问权限修饰符修饰时,被修饰的内容会有不同的访问权限,
3.2 不同权限的访问能力
public protected (空的) private
同一类中 √ √ √ √
同一包中(子类与无关类) √ √ √
不同包的子类 √ √
不同包中的无关类 √
包:com.itheima.demo9_权限修饰符
public class AAA {
public void method1(){}
protected void method2(){}
void method3(){}
private void method4(){}
// 同一个类中
public void method(){
method1();
method2();
method3();
method4();
}
}
public class Test {
public static void main(String[] args) {
AAA a = new AAA();
a.method1();
a.method2();
a.method3();
// a.method4(); 私有方法 编译报错
}
}
包:com.itheima.demo10_权限修饰符
public class Zi extends AAA {
public void show(){
method1();
method2();
//method3();编译报错
//method4();编译报错
}
}
public class Test {
public static void main(String[] args) {
AAA a = new AAA();
a.method1();
//a.method2();// 编译报错
//a.method3();// 编译报错
//a.method4();// 编译报错
}
}
可见,public具有最大权限。private则是最小权限。
编写代码时,如果没有特殊的考虑,建议这样使用权限:
小结
略
第二章 代码块
目标:
路径:
讲解:
4.1 构造代码块
格式: {}
位置: 类中,方法外
执行: 每次在调用构造方法的时候,就会执行. 比构造方法执行要早
使用场景: 统计创建了多少个该类对象
例如:
public class Person{
{
构造代码块执行了
}
}
4.2 静态代码块
格式:
格式:static{}
位置: 类中,方法外
执行: 当类被加载的时候执行,并只执行一次
使用场景: 例如加载驱动,这种只需要执行一次的代码就可以放在静态代码块中
public class Person {
private String name;
private int age;
//静态代码块
static{
System.out.println("静态代码块执行了");
}
}
4.3 局部代码块
格式:{}
位置: 方法中
执行: 调用方法,执行到局部代码块的时候就执行
使用场景: 节省内存空间,没有多大的意义
例如:
public static void main(String[] args) {
int a = 10;
//局部代码块
//局部代码块的作用就是限制变量的作用域,早早的从内存中消失,节约内存
//但是现在内存不值钱,所以局部代码块没有使用意义
{
int b = 20;
}
//int a = 30; //在同一个区域不能定义重名变量
//不报错,以为作用域不同
int b = 40;
}
小结
第三章 static的使用
2.1 概述
static是静态修饰符,一般修饰成员。被static修饰的成员属于类,不属于单个这个类的某个对象。static修饰的成员被多个对象共享。static修饰的成员属于类,但是会影响每一个对象。被static修饰的成员又叫类成员,不叫对象的成员。
2.2 定义和使用格式
类变量
当 static 修饰成员变量时,该变量称为类变量。该类的每个对象都共享同一个类变量的值。任何对象都可以更改该类变量的值,但也可以在不创建该类的对象的情况下对类变量进行操作。
定义格式:
static 数据类型 变量名;
举例:
static String room;
比如说,同学们来黑马程序员学校学习,那么我们所有同学的学校都是黑马程序员, 不因每个同学不同而不同。
所以,我们可以这样定义一个静态变量school,代码如下:
public class Student {
private String name;
private int age;
// 类变量,记录学生学习的学校
public static String school = "黑马程序员学校";
public Student(String name, int age){
this.name = name;
this.age = age;
}
// 打印属性值
public void show() {
System.out.println("name=" + name + ", age=" + age + ", shool=" + shool );
}
}
public class StuDemo {
public static void main(String[] args) {
Student s1 = new Student("张三", 23);
Student s2 = new Student("李四", 24);
Student s3 = new Student("王五", 25);
Student s4 = new Student("赵六", 26);
s1.show(); // Student : name=张三, age=23, shool=黑马程序员学校
s2.show(); // Student : name=李四, age=24, shool=黑马程序员学校
s3.show(); // Student : name=王五, age=25, shool=黑马程序员学校
s4.show(); // Student : name=赵六, age=26, shool=黑马程序员学校
}
}
静态方法
当static 修饰成员方法时,该方法称为类方法 。静态方法在声明中有static ,建议使用类名来调用,而不需要创建类的对象。调用方式非常简单。
定义格式:
修饰符 static 返回值类型 方法名 (参数列表){
// 执行语句
}
举例:在Student类中定义静态方法
public static void showNum() {
System.out.println("num:" + numberOfStudent);
}
小贴士:静态方法只能访问静态成员。
调用格式
被static修饰的成员可以并且建议通过类名直接访问。虽然也可以通过对象名访问静态成员,原因即多个对象均属于一个类,共享使用同一个静态成员,但是不建议,会出现警告信息。
格式:
// 访问类变量
类名.类变量名;
// 调用静态方法
类名.静态方法名(参数);
调用演示,代码如下:
public class StuDemo2 {
public static void main(String[] args) {
// 访问类变量
System.out.println(Student.numberOfStudent);
// 调用静态方法
Student.showNum();
}
}
小结:static修饰的内容是属于类的,可以通过类名直接访问
第四章 Object类
知识点-- Object类概述
目标:
路径:
讲解:
Object类的概述
数组: 也继承了Object类中的方法
// ...
}小结
知识点-- toString方法
目标:
路径:
讲解:
toString方法的概述
toString方法的源代码
public String toString() {
// getClass() : 获取类的字节码文件对象
// this.getClass().getName() : 当前类的全限定类名(全路径类名) -> 从第一个包名开始一直到最后的类名
return this.getClass().getName() : + "@" + Integer.toHexString(this.hashCode());
// this.hashCode() : 获取哈希码值, 哈希码值是由地址值计算出来的
// public native int hashCode(); 本地方法
// Integer.toHexString() : 调用了Integer类中的toHexString()方法
// 作用是: 转换十六进制
}
由于toString方法返回的结果是内存地址,而在开发中,经常需要按照对象的属性得到相应的字符串表现形式,因此也需要重写它。
重写toString方法
如果不希望使用toString方法的默认行为,则可以对它进行覆盖重写。例如自定义的Person类:
public class Person {
private String name;
private int age;
// alt + insert -> toString() 回车
@Override
public String toString() {
return "Person{" + "name='" + name + '\'' + ", age=" + age + '}';
}
// 省略构造器与Getter Setter
}
在IntelliJ IDEA中,可以点击Code菜单中的Generate...,也可以使用快捷键alt+insert,点击toString()选项。选择需要包含的成员变量并确定。
小贴士: 在我们直接使用输出语句输出对象名的时候,其实通过该对象调用了其toString()方法。
小结
知识点-- equals方法
目标:
路径:
讲解:
equals方法的概述
equals方法的使用
默认地址比较
Object类的equals()方法默认实心是==比较,也就是比较2个对象的地址值,对于我们来说没有用
Object类中equals的源代码
p1.equals(p2)
// ======================================
public boolean equals(Object obj) {
// this : p1
// obj : p2
return this == obj; // 比较地址值
}
对象内容比较
如果希望进行对象的内容比较,即所有或指定的部分成员变量相同就判定两个对象相同,则可以覆盖重写equals方法。例如:
import java.util.Objects;
public class Person {
private String name;
private int age;
@Override
public boolean equals(Object o) {
// 如果对象地址一样,则认为相同
if (this == o)
return true;
// 如果参数为空,或者类型信息不一样,则认为不同
if (o == null || getClass() != o.getClass())
return false;
// 转换为当前类型
Person person = (Person) o;
// 要求基本类型相等,并且将引用类型交给java.util.Objects类的equals静态方法取用结果
return age == person.age && Objects.equals(name, person.name);
}
}
这段代码充分考虑了对象为空、类型一致等问题,但方法内容并不唯一。大多数IDE都可以自动生成equals方法的代码内容。在IntelliJ IDEA中,可以使用Code菜单中的Generate…选项,也可以使用快捷键alt+insert,并选择equals() and hashCode()进行自动代码生成。
tips:Object类当中的hashCode等其他方法,今后学习。
小结
2.如果在开发中,希望调用equals方法比较的不是2个对象的地址值,那么就需要重写equals方法,指定比较规则
一般开发中,重写toString方法,使用idea的快捷键alt+insert--->equals and hashCode 回车
知识点-- Objects类
目标:
路径:
讲解:
在刚才IDEA自动重写equals代码中,使用到了java.util.Objects类,那么这个类是什么呢?
在JDK7添加了一个Objects工具类,它提供了一些方法来操作对象,它由一些静态的实用方法组成,这些方法是null-save(空指针安全的)或null-tolerant(容忍空指针的),用于计算对象的hashCode、返回对象的字符串表示形式、比较两个对象。
在比较两个对象的时候,Object的equals方法容易抛出空指针异常,而Objects类中的equals方法就优化了这个问题。方法如下:
我们可以查看一下源码,学习一下:
public static boolean equals(Object a, Object b) {
return (a == b) || (a != null && a.equals(b));
}
小结
略
知识点-- native方法
目标
路径
讲解
在Object类的源码中定义了 native 修饰的方法, native 修饰的方法称为本地方法。这种方法是没有方法体的,我们查看不了它的实现,所以大家不需要关心该方法如何实现的
Object类源码(部分):
package java.lang;
/**
* Class {@code Object} is the root of the class hierarchy.
* Every class has {@code Object} as a superclass. All objects,
* including arrays, implement the methods of this class.
*
* @author unascribed
* @see java.lang.Class
* @since JDK1.0
*/
public class Object {
//本地方法
private static native void registerNatives();
//静态代码块
static {
registerNatives();
}
......
......
}
小结
略
第五章 Date类
知识点--Date类
目标:
路径:
讲解:
Date类的概述
java.util.Date类 表示一个日期和时间,内部精确到毫秒。
Date类中的构造方法
继续查阅Date类的描述,发现Date拥有多个构造函数,只是部分已经过时,我们重点看以下两个构造函数
tips: 由于中国处于东八区(GMT+08:00)是比世界协调时间/格林尼治时间(GMT)快8小时的时区,当格林尼治标准时间为0:00时,东八区的标准时间为08:00。
简单来说:使用无参构造,可以自动设置当前系统时间的毫秒时刻;指定long类型的构造参数,可以自定义毫秒时刻。例如:
import java.util.Date;
public class Demo01Date {
public static void main(String[] args) {
// 创建当前系统日期对象
Date date1 = new Date();
System.out.println("date1:"+date1);
// 创建以标准基准时间为基准 指定偏移毫秒数 对应的日期对象
Date date2 = new Date(2000);// 1970年1月1日 08:00:02
System.out.println("date2:"+date2);
}
}
tips:在使用println方法时,会自动调用Date类中的toString方法。Date类对Object类中的toString方法进行了覆盖重写,所以结果为指定格式的字符串。
Date类中的常用方法
Date类中的多数方法已经过时,常用的方法有:
示例代码
public class DateDemo02 {
public static void main(String[] args) {
// 创建当前系统日期对象
Date date1 = new Date();
System.out.println("date1:"+date1);
// 创建以标准基准时间为基准 指定偏移毫秒数 对应的日期对象
Date date2 = new Date(2000);// 1970年1月1日 08:00:02
System.out.println("date2:"+date2);
System.out.println("==============================================");
// 获取date1对象距离标准基准时间的毫秒值。
long date1Time = date1.getTime();
System.out.println("date1Time:"+date1Time);// date1Time:1576637585666
// 获取date2对象距离标准基准时间的毫秒值。
long date2Time = date2.getTime();
System.out.println("date2Time:"+date2Time);// date2Time:2000
System.out.println("==============================================");
date2.setTime(1000);
System.out.println("date2:"+date2);
}
}
小结
第六章 DateFormat类
知识点--DateFormat类
目标:
路径:
讲解:
DateFormat类的概述
java.text.DateFormat 是日期/时间格式化子类的抽象类,我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以在Date对象与String对象之间进行来回转换。
由于DateFormat为抽象类,不能直接使用,所以需要常用的子类java.text.SimpleDateFormat。这个类需要一个模式(格式)来指定格式化或解析的标准。构造方法为:
格式规则
常用的格式规则为:
标识字母(区分大小写) 含义
y 年
M 月
d 日
H 时
m 分
s 秒
备注:更详细的格式规则,可以参考SimpleDateFormat类的API文档。
常用方法
DateFormat类的常用方法有:
public class SimpleDateFormatDemo {
public static void main(String[] args) throws ParseException {
//格式化:从 Date 到 String
Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
String s = sdf.format(d);
System.out.println(s);
System.out.println("--------");
//从 String 到 Date
String ss = "2048-08-09 11:11:11";
//ParseException
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date dd = sdf2.parse(ss);
System.out.println(dd);
}
}
小结:
实操--日期类练习
需求
分析
讲解
public static void main(String[] args) throws Exception{
//从控制台接收用户的生日——String类型,例如:"1998-03-18"
Scanner sc = new Scanner(System.in);
System.out.println("请输入你的生日(yyyy-MM-dd):");
String birthDay = sc.next();
//1.计算生日的毫秒值
//将birthDay转换为Date对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date birthDate = sdf.parse(birthDay);
//取毫秒值
long m1 = birthDate.getTime();
//2.计算现在的毫秒值
long m2 = new Date().getTime();
System.out.println("你出生到现在一共经历了:" + ((m2 - m1) / 1000 / 3600 / 24) + " 天");
}
小结
略
第七章 Calendar类
知识点--Calendar类
目标:
路径:
讲解:
Calendar类的概述
Calendar类的常用方法
public static Calendar getInstance() 获取当前日期的日历对象
public int get(int field) 获取某个字段的值。
public void set(int field,int value) 设置某个字段的值
public void set( int year, int month, int date,int hourOfDay,int minute,int second )
public void add(int field,int amount)为某个字段增加/减少指定的值
额外扩展2个方法:
void setTime(Date date) 使用给定的 Date 设置此 Calendar 的时间。
boolean before(Object when) 判断此 Calendar 表示的时间是否在指定 Object 表示的时间之前,返回判断结果。
public class Demo {
public static void main(String[] args) throws ParseException {
// 获取当前日期的日历对象
Calendar nowCal = Calendar.getInstance();// 2019年12月18日
// 出生日期的日历对象
String birtday = "2017年11月11日";
// 创建日期格式化对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
// 把String转换为Date
Date birthdayDate = sdf.parse(birtday);
// 把出生日期Date对象 转换为 Calendar日历对象
Calendar birthdayCal = Calendar.getInstance();
birthdayCal.setTime(birthdayDate);
// 比较当前日历对象nowCal 与 出生日期日历对象 birthdayCal
System.out.println(birthdayCal.before(nowCal));// true
System.out.println(nowCal.before(birthdayCal));// false
}
/**
* setTime方法
*/
private static void method02() {
// 获取日历对象
Calendar cal1 = Calendar.getInstance();
System.out.println(cal1);// 当前日期对应的日历对象
/*
java.util.GregorianCalendar[time=1576641557775,areFieldsSet=true,areAllFieldsSet=true,
lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,
dstSavings=0,useDaylight=false,transitions=19,lastRule=null],firstDayOfWeek=1,
minimalDaysInFirstWeek=1,ERA=1,YEAR=2019,MONTH=11,WEEK_OF_YEAR=51,WEEK_OF_MONTH=3,
DAY_OF_MONTH=18,DAY_OF_YEAR=352,DAY_OF_WEEK=4,DAY_OF_WEEK_IN_MONTH=3,AM_PM=0,HOUR=11,
HOUR_OF_DAY=11,MINUTE=59,SECOND=17,MILLISECOND=775,ZONE_OFFSET=28800000,DST_OFFSET=0]
*/
// 设置指定的Date为cal1日历对象的时间
Date date = new Date(1000);// 1970-01-01 08:00:01
cal1.setTime(date);
System.out.println(cal1);
/*
java.util.GregorianCalendar[time=1000,areFieldsSet=true,areAllFieldsSet=true,
lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,
dstSavings=0,useDaylight=false,transitions=19,lastRule=null],firstDayOfWeek=1,
minimalDaysInFirstWeek=1,ERA=1,YEAR=1970,MONTH=0,WEEK_OF_YEAR=1,WEEK_OF_MONTH=1,
DAY_OF_MONTH=1,DAY_OF_YEAR=1,DAY_OF_WEEK=5,DAY_OF_WEEK_IN_MONTH=1,AM_PM=0,HOUR=8,
HOUR_OF_DAY=8,MINUTE=0,SECOND=1,MILLISECOND=0,ZONE_OFFSET=28800000,DST_OFFSET=0]
*/
}
private static void method01() {
// 获取日历对象
GregorianCalendar cal1 = new GregorianCalendar();
Calendar cal2 = Calendar.getInstance();
System.out.println(cal1);
System.out.println(cal2);
/*
java.util.GregorianCalendar[time=1576639674053,areFieldsSet=true,areAllFieldsSet=true,
lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,
dstSavings=0,useDaylight=false,transitions=19,lastRule=null],firstDayOfWeek=1,
minimalDaysInFirstWeek=1,ERA=1,YEAR=2019,MONTH=11,WEEK_OF_YEAR=51,WEEK_OF_MONTH=3,
DAY_OF_MONTH=18,DAY_OF_YEAR=352,DAY_OF_WEEK=4,DAY_OF_WEEK_IN_MONTH=3,AM_PM=0,HOUR=11,
HOUR_OF_DAY=11,MINUTE=27,SECOND=54,MILLISECOND=53,ZONE_OFFSET=28800000,DST_OFFSET=0]
*/
// 分别日历对象中的关于时间的信息
// 获取日历字段中的年
int year = cal2.get(Calendar.YEAR);
System.out.println("年:"+year);// 年:2019
// 获取日历字段的月
int month = cal2.get(Calendar.MONTH);
System.out.println("月:"+(month+1));// 12
System.out.println("日:"+cal2.get(Calendar.DAY_OF_MONTH));//18
System.out.println("=============================");
// 修改cal2日历对象中的年为2099
cal2.set(Calendar.YEAR,2099);
System.out.println("修改后的年:"+cal2.get(Calendar.YEAR));// 修改后的年:2099
// 修改cal2日历对象中的月份为12
// cal2.set(Calendar.MONTH,12);
// System.out.println("修改后的月:"+cal2.get(Calendar.MONTH));// 0
System.out.println("=============================");
// 为cal2日历对象中的年增加2年
cal2.add(Calendar.YEAR,2);
System.out.println("增加2年后的年:"+cal2.get(Calendar.YEAR));// 增加2年后的年:2101
// 为cal2日历对象中的年减少5年
cal2.add(Calendar.YEAR,-5);
System.out.println("减少5年后的年:"+cal2.get(Calendar.YEAR));// 减少5年后的年:2096
}
}
注意
小结
略
第八章 Math类
知识点-- Math类
目标:
步骤:
路径:
Math类的概述
Math类的常用方法
public static int abs(int a) 获取参数a的绝对值:
public static double ceil(double a) 向上取整 例如:3.14 向上取整4.0
public static double floor(double a) 向下取整 例如:3.14 向下取整3.0
public static double pow(double a, double b) 获取a的b次幂
public static long round(double a) 四舍五入取整 例如:3.14 取整3 3.56 取整4
public static int max(int a, int b) 返回两个 int 值中较大的一个。
public static int min(int a, int b) 返回两个 int 值中较小的一个。
案例代码
public class Demo {
public static void main(String[] args) {
System.out.println("10的绝对值:"+Math.abs(10));// 10
System.out.println("-10的绝对值:"+Math.abs(-10));// 10
System.out.println("3.14向上取整:"+Math.ceil(3.14));// 4.0
System.out.println("3.54向上取整:"+Math.ceil(3.54));// 4.0
System.out.println("-3.54向上取整:"+Math.ceil(-3.54));// -3.0
System.out.println("==================================");
System.out.println("3.14向下取整:"+Math.floor(3.14));// 3.0
System.out.println("3.54向下取整:"+Math.floor(3.54));// 3.0
System.out.println("-3.54向下取整:"+Math.floor(-3.54));// -4.0
System.out.println("==================================");
System.out.println("2的3次幂:"+Math.pow(2,3));// 8.0
System.out.println("==================================");
System.out.println("3.14四舍五入取整:"+Math.round(3.14));// 3
System.out.println("3.54四舍五入取整:"+Math.round(3.54));// 4
System.out.println("-3.54四舍五入取整:"+Math.round(-3.54));// -4
System.out.println("==================================");
System.out.println("获取10和20之间的最大值:"+Math.max(10,20));// 20
System.out.println("获取10和20之间的最小值:"+Math.min(10,20));// 10
}
}
小结
略
第九章 System
知识点--System类
目标:
路径:
讲解:
System类的概述
java.lang.System类中提供了大量的静态方法,可以获取与系统相关的信息或系统级操作。
System类的常用方法
public static void exit(int status) 终止当前运行的Java虚拟机,非零表示异常终止
public static long currentTimeMillis() 返回当前时间(以毫秒为单位)
static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 拷贝数组中的元素到另一个数组
参数1src: 源数组
参数2srcPos:源数组要拷贝的元素的起始索引(从哪个索引位置开始拷贝)
参数3dest: 目标数组
参数4destPos:目标数组接收拷贝元素的起始索引(从哪个索引位置开始接收)
参数5length:需要拷贝多少个元素(拷贝多少个)
案例代码
public class Demo {
public static void main(String[] args) {
/* System.out.println("Hello World!1");
System.out.println("Hello World!2");
// 结束程序运行
System.exit(0);
System.out.println("Hello World!3");*/
System.out.println("==========================================");
long time = System.currentTimeMillis();
System.out.println("time:"+time);
long time2 = new Date().getTime();
System.out.println("time2:"+time2);
System.out.println("==========================================");
int[] src = {1,2,3,4,5,6,7};
int[] dest = {10,20,30,40,50,60,70};
// 需求:把src数组中的2,3,4拷贝到dest目标数组中,使得目标数组的元素为:{10,20,30,2,3,4,70};
System.arraycopy(src,1,dest,3,3);
// System.out.println("源数组:"+Arrays.toString(src));
// System.out.println("目标数组:"+Arrays.toString(dest));
for (int i = 0; i < dest.length; i++) {
System.out.println(dest[i]);
}
}
小结
略
实操--练习
需求
分析
讲解
import java.util.Date;
//验证for循环打印数字1-9999所需要使用的时间(毫秒)
public class SystemDemo {
public static void main(String[] args) {
//获取当前时间毫秒值
long start = System.currentTimeMillis();
// 循环在控制台输出1-10000
for (int i = 1; i <= 10000; i++) {
System.out.println(i);
}
// 获取循环结束后的毫秒值
long end = System.currentTimeMillis();
// 计算程序运行时间
System.out.println("共耗时毫秒:" + (end - start));
}
}
小结
略
第十章 BigInteger类
知识点--BigInteger类
目标
路径
讲解
BigInteger类的概述
java.math.BigInteger 类,不可变的任意精度的整数。如果运算中,数据的范围超过了long类型后,可以使用 BigInteger类实现,该类的计算整数是不限制长度的。
BigInteger类的构造方法
BigInteger类成员方法
BigInteger类提供了对很大的整数进行加add、减subtract、乘multiply、除divide的方法,注意:都是与另一个BigInteger对象进行运算。
方法声明 描述
add(BigInteger value) 返回其值为 (this + val) 的 BigInteger,超大整数加法运算
subtract(BigInteger value) 返回其值为 (this - val) 的 BigInteger,超大整数减法运算
multiply(BigInteger value) 返回其值为 (this * val) 的 BigInteger,超大整数乘法运算
divide(BigInteger value) 返回其值为 (this / val) 的 BigInteger,超大整数除法运算,除不尽取整数部分
【示例】
public class Test {
public static void main(String[] args) {
// 创建一个BigInteger类的对象,表示一个无限大的整数
BigInteger b1 = new BigInteger("1000000000000000000000");
BigInteger b2 = new BigInteger("1223435453543654354354");
// b1 + b2
BigInteger res1 = b1.add(b2);
System.out.println("b1 + b2 = "+res1);// 2223435453543654354354
// b1 - b2
BigInteger res2 = b1.subtract(b2);
System.out.println("b1 - b2 = " + res2);// -223435453543654354354
// b1 * b2
BigInteger res3 = b1.multiply(b2);
System.out.println("b1 * b2 = "+res3);// 1223435453543654354354000000000000000000000
// b1 / b2
BigInteger res4 = b1.divide(b2);
System.out.println("b1 / b2 = " + res4);// 0 10/3=3
// int a = 1000000000000;// 编译报错,因为超出了int类型所能表示的数据范围
// long l = 1000000000000000000000L;// 编译报错,因为超出了long类型所能表示的数据范围
}
}
小结
略
第十一章 BigDecimal类
知识点-- BigDecimal类
目标:
路径:
讲解:
BigDecimal类的概述
使用基本类型做浮点数运算精度问题;
看程序说结果:
public static void main(String[] args) {
System.out.println(0.09 + 0.01);
System.out.println(1.0 - 0.32);
System.out.println(1.015 * 100);
System.out.println(1.301 / 100);
}
BigDecimal类构造方法
构造方法名 描述
BigDecimal(double val) 将double类型的数据封装为BigDecimal对象
BigDecimal(String val) 将 BigDecimal 的字符串表示形式转换为 BigDecimal
注意:推荐使用第二种方式,第一种存在精度问题;
BigDecimal类常用方法
BigDecimal类中使用最多的还是提供的进行四则运算的方法,如下:
方法声明 描述
public BigDecimal add(BigDecimal value) 加法运算
public BigDecimal subtract(BigDecimal value) 减法运算
public BigDecimal multiply(BigDecimal value) 乘法运算
public BigDecimal divide(BigDecimal value) 除法运算
注意:对于divide方法来说,如果除不尽的话,就会出现java.lang.ArithmeticException异常。此时可以使用divide方法的另一个重载方法;
BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode): divisor:除数对应的BigDecimal对象;scale:精确的位数;roundingMode取舍模式
RoundingMode枚举: RoundingMode.HALF_UP 四舍五入
public class Test {
public static void main(String[] args) {
// 除得尽
BigDecimal b1 = new BigDecimal("10");
BigDecimal b2 = new BigDecimal("2");
System.out.println(b1.divide(b2));// 5
// 除不尽
BigDecimal b3 = new BigDecimal("10");
BigDecimal b4 = new BigDecimal("3");
//System.out.println(b3.divide(b4));// 运行报异常,ArithmeticException数学运算异常
System.out.println(b3.divide(b4, 4, RoundingMode.HALF_UP));// 3.3333
//double num1 = 10;
//double num2 = 3;
//System.out.println(num1/num2);// 3.3333333333333335
// BigDecimal类的构造方法
// BigDecimal b1 = new BigDecimal(0.09);
// BigDecimal b2 = new BigDecimal("0.09");
// System.out.println(0.09+0.01);// 0.09999999999999999 ---->无限趋近0.1的小数
// System.out.println(1.0 - 0.32);// 0.6799999999999999 ---->无限趋近0.68的小数
// System.out.println(1.015 * 100);// 101.49999999999999 --->无限趋近101.5的小数
// System.out.println(1.301 / 100);// 0.013009999999999999-->无限趋近0.01301的小数
}
/**
* BigDecimal类的减,乘,除法运算
*/
private static void method02() {
//创建BigDecimal对象,表示小数:1.0
BigDecimal b1 = new BigDecimal("1.0");
//创建BigDecimal对象,表示小数:0.32
BigDecimal b2 = new BigDecimal("0.32");
// 减法运算
System.out.println(b1.subtract(b2));// 0.68
//创建BigDecimal对象,表示小数:1.015
BigDecimal b3 = new BigDecimal("1.015");
//创建BigDecimal对象,表示小数:100
BigDecimal b4 = new BigDecimal("100");
// 乘法运算
System.out.println(b3.multiply(b4));// 101.500
//创建BigDecimal对象,表示小数:1.301
BigDecimal b5 = new BigDecimal("1.301");
//创建BigDecimal对象,表示小数:100
BigDecimal b6 = new BigDecimal("100");
// 乘法运算
System.out.println(b5.divide(b6));// 0.01301
}
/**
* 加法运算
*/
private static void method01() {
// 创建BigDecimal对象,表示小数:0.09
BigDecimal b1 = new BigDecimal("0.09");
// 创建BigDecimal对象,表示小数:0.01
BigDecimal b2 = new BigDecimal("0.01");
// 加法运算
System.out.println(b1.add(b2));// 0.10
// 创建BigDecimal对象,表示小数:0.09
BigDecimal b3 = new BigDecimal(0.09);
// 创建BigDecimal对象,表示小数:0.01
BigDecimal b4 = new BigDecimal(0.01);
// 加法运算
System.out.println(b3.add(b4));// 0.09999999999999999687749774324174723005853593349456787109375
}
}
小结:
第十二章 Arrays类
知识点-- Arrays类
目标
路径
讲解
3.1 Arrays类概述
java.util.Arrays类:该类包含用于操作数组的各种方法(如排序和搜索)
3.2 Arrays类常用方法
public static void main(String[] args) {
int[] arr = {432, 53, 6, 323, 765, 7, 254, 37, 698, 97, 64, 7};
//将数组排序
Arrays.sort(arr);
//打印数组
System.out.println(Arrays.toString(arr));
}
打印结果:[6, 7, 7, 37, 53, 64, 97, 254, 323, 432, 698, 765]
小结
略
第十三章 包装类
知识点-- 包装类的概述
目标
路径
讲解
包装类的概述
Java提供了两个类型系统,基本类型与引用类型,使用基本类型在于效率,然而很多情况,会创建对象使用,因为对象可以做更多的功能,如果想要我们的基本类型像对象一样操作,就可以使用基本类型对应的包装类,如下:
基本类型 对应的包装类(位于java.lang包中)
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
小结
略
知识点-- Integer类
目标
路径
讲解
Integer类概述
包装一个对象中的原始类型 int 的值
Integer类构造方法及静态方法
方法名 说明
public Integer(int value) 根据 int 值创建 Integer 对象(过时)
public Integer(String s) 根据 String 值创建 Integer 对象(过时)
public static Integer valueOf(int i) 返回表示指定的 int 值的 Integer 实例
public static Integer valueOf(String s) 返回保存指定String值的 Integer 对象
示例代码
public class IntegerDemo {
public static void main(String[] args) {
//public Integer(int value):根据 int 值创建 Integer 对象(过时)
Integer i1 = new Integer(100);
System.out.println(i1);
//public Integer(String s):根据 String 值创建 Integer 对象(过时)
Integer i2 = new Integer("100");
//Integer i2 = new Integer("abc"); //NumberFormatException
System.out.println(i2);
System.out.println("--------");
//public static Integer valueOf(int i):返回表示指定的 int 值的 Integer 实例
Integer i3 = Integer.valueOf(100);
System.out.println(i3);
//public static Integer valueOf(String s):返回保存指定String值的Integer对象
Integer i4 = Integer.valueOf("100");
System.out.println(i4);
}
}
小结
略
知识点--装箱与拆箱
目标:
路径:
讲解:
装箱与拆箱的概述
基本类型与对应的包装类对象之间,来回转换的过程称为”装箱“与”拆箱“:
自动装箱与自动拆箱
由于我们经常要做基本类型与包装类之间的转换,从Java 5(JDK 1.5)开始,基本类型与包装类的装箱、拆箱动作可以自动完成。例如:
Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4);
int a = i + 5;//等号右边:将i对象转成基本数值(自动拆箱) i.intValue() + 5;
小结
知识点--基本类型与字符串之间的转换
目标:
步骤:
讲解:
基本类型转换为String
转换方式
方式一:直接在数字后加一个空字符串
方式二:通过String类静态方法valueOf()
示例代码
public class IntegerDemo {
public static void main(String[] args) {
//int --- String
int number = 100;
//方式1
String s1 = number + "";
System.out.println(s1);
//方式2
//public static String valueOf(int i)
String s2 = String.valueOf(number);
System.out.println(s2);
System.out.println("--------");
}
}
String转换成基本类型
除了Character类之外,其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型:
代码使用(仅以Integer类的静态方法parseXxx为例)如:
转换方式
示例代码
public class IntegerDemo {
public static void main(String[] args) {
//String --- int
String s = "100";
//方式1:String --- Integer --- int
Integer i = Integer.valueOf(s);
//public int intValue()
int x = i.intValue();
System.out.println(x);
//方式2
//public static int parseInt(String s)
int y = Integer.parseInt(s);
System.out.println(y);
}
}
注意:如果字符串参数的内容无法正确转换为对应的基本类型,则会抛出java.lang.NumberFormatException异常。
小结
略
总结
本站主要用于,日常笔记的记录,和生活日志。本站不保证所有内容信息可靠!(大多数文章属于搬运!)如有版权问题!请联系我立即删除“abcdsjx@126.com”
QQ: 1164453243
邮箱: abcdsjx@126.com