第4章章目录
- 1 面向对象特征之二：继承
- 2 方法的重写（override)
- 3 四种访问权限修饰符
- 4 关键字super
- ✔练习 1.修改子类中方法，在该方法中调用父类方法；2.在类中覆盖原方法
- 5 子类对象实例化过程（栈，堆，方法区）
- 6 面向对象特征之三：多态
- 7 Object类
- ✔ 操作符==与equals方法总结
- ★String对象的创建过程
- ✔ 练习 1.用equals,==比较变量和对象2.编写Order类，判断同类的两对象是否相等
- ✔ Object类的toString方法
- ✔ 打印数组的方法Arrays.toString,多维数组Arrays.deepToString
- 8 包装类
- ✔ 关于在方法中使用时的装箱，以包装类对象.compareTo(包装类对象作为参数)方法为例。其中参数部分可以直接填基本数据类型，会自动装箱
1 面向对象特征之二：继承
人类{
姓名
性别
年龄
打印信息的方法
}
学生类{
姓名
性别
年龄
学校
打印信息的方法
}
工人类{
姓名
性别
年龄
工种
打印信息的方法
}
教师类{
姓名
性别
年龄
科目
打印信息方法
}
问题？
按照上面说的把代码写出来，总是有四个类成员重复。
用继承
子类的共性代码都是继承自父类的，每个子类只要写自己的特有的代码
把共性抽取出来形成父类，实际需求的子类在继承父类的基础上写自己特有代码即可
package day07;
public class ManKind {
int sex;
int salary;
void manOrWormen(){
if(this.sex == 1){
System.out.println("man");
}else if(this.sex == 0){
System.out.println("women");
}
}
void employeed(){
if(this.salary == 0){
System.out.println("no job");
}else if (this.salary != 0){
System.out.println("job");
}
}
public int getSex() {
return sex;
}
public void setSex(int sex) {
this.sex = sex;
}
public int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
}
package day07;
public class Kids extends ManKind {
int yearsOld;
public void printAge(){
System.out.println(this.yearsOld);
}
public int getYearsOld() {
return yearsOld;
}
public void setYearsOld(int yearsOld) {
this.yearsOld = yearsOld;
}
public static void main(String[] args){
Kids someKid = new Kids();
someKid.setSex(0) ;
someKid.setSalary(100);
someKid.manOrWormen();
someKid.employeed();
}
}
package day07;
public class Circle {
Circle(){
this.radius = 1;
}
double radius;
public double findArea(){
return 3.1415*radius*radius;
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
}
package day07;
public class Cylinder extends Circle{
Cylinder(){
this.length = 1;
}
double length;
public double findVolume(){//底面积
return length*this.findArea();
}
public double getLength() {
return length;
}
public void setLength(double length) {
this.length = length;
}
}
package day07;
public class TestCylinder {
public static void main(String[] args){
Cylinder c1 = new Cylinder();
c1.setRadius(5.6);
c1.setLength(6.9);
System.out.println(c1.findVolume());
}
}
2 方法的重写（override)
Alt+/（IDEA是Ctrl+o）打开智能提醒
例如：
Person类是Student类的父类，在Student类中重写方法
Ctrl+o打开智能提醒，选择方法showInfo()
没有在子类重写的情况，是调用父类的方法
如果子类中调用父类的方法，子类有重写。优先调用本类重写的
方法的重载：一个类可以有多个同名方法
方法的重写：子类可以重新写父类的方法，覆盖父类的方法
1.因为default访问权限比public严格
而子类重写方法时，不能使用比父类更严格的访问权限
2.
3 四种访问权限修饰符
4 关键字super
复习一下，继承中。子类是全部继承父类的所有属性和方法，包括private的。此处调用应是回溯父类的，而不是子类继承的属性，方法和构造器。
//ManKind.java
package com.qxcto;
public class ManKind {
int sex;
int salary;
public int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
public int getSex(){
return sex;
}
public void setSex(int sex){
this.sex = sex;
}
public void manOrWomen(){
if(this.sex == 1){
System.out.println("man");
}else if(this.sex == 0){
System.out.println("women");
}
}
public void employeed(){
if(this.salary == 0 ){
System.out.println("no job");
}else{
System.out.println("job");
}
}
}
//Kids.java
package com.qxcto;
public class Kids extends ManKind{
int yearsOld;
public int getYearsOld(){
return yearsOld;
}
public void setyearsOld(int yearsOld){
this.yearsOld = yearsOld;
}
public void printAge(){
System.out.println(this.yearsOld);
}
/**
*
*/
@Override
public void employeed() {
super.employeed();
System.out.println("but Kids should study and no job");
}
}
//Kk.java
package com.qxcto;
public class Kk extends Kids{
public void test(){
super.salary = 1;//可以使用super向上追溯父类的父类，当然可以一直向上追溯，如果有那么多个层级的父类的话
super.yearsOld = 1;//可以使用super直接追溯使用父类的成员变量
super.employeed();//可以使用super直接追溯使用父类的成员方法
super.manOrWomen();//可以使用super向上追溯父类的父类的成员方法，可以一直向上追溯，如果有那么多个层级的父类的话
}
}
发现当Kk使用super调用父类的employeed方法时，调用的是父类重写的爷爷类的employeed方法，并非爷爷类中的employeed方法
why?因为父类中有重写employeed方法
✔练习 1.修改子类中方法，在该方法中调用父类方法；2.在类中覆盖原方法
1.
底面积×高，计算体积
>在子类中重写父类的findArea方法，在圆柱体积方法中，将子类的计算圆面积方法（修改后为计算圆柱体表面积）this.findArea改为父类的计算圆面积方法即使用super.findArea()调用
3.附加
c2.findArea()为子类调用计算表面积。c3.findArea()为父类调用计算面积
4.1 调用父类的构造器
第一条：说明如图在父类ManKind中构造显示无参构造器
实例化子类Kids后，调用父类的无参构造器
类似于写为在子类构造器中调用父类无参构造器
第二条，复习构造器。调用父类的显示构造器
第三条，子类无显示构造父类的有参构造，但不报错。可默认调用父类的无参构造
若子类想如第一条所说，默认调用父类的无参构造器，但是父类构造了显示有参构造。需要再显示构造无参构造（因为一旦显示构造，系统默认的隐式无参构造将不再构造）
4.2 this和super的区别
5 子类对象实例化过程（栈，堆，方法区）
5.1 简单类对象的实例化过程
5.2 ★子类对象的实例化过程(内存空间示意）
6 面向对象特征之三：多态
重载：本类中的同名方法。体现相同的名称方法，实现不同的逻辑
重写：子类对父类方法的覆盖。子类可以使用和父类相同的方法名，覆盖掉父类的逻辑。
父类的方法想修改逻辑，但是有别的代码在调用父类的方法，可以考虑用子类继承父类，重写父类的方法（体现重写的多态性）
6.1 对象的多态
编译时和运行时类型不一致，就出现多态。就是对象的多态
向上转型：把子类的对象可以给父类类型的变量引用（Person e = new Student();）
Student s = new Student();
s.school = "xxxx";
Person e = new Student();
//错误写法：e.school = "xxx";//属性是在编译时确定的，编译时e为Person类型，没有school成员变量，因而编译错误。
//Person里没有school属性
6.2 ★虚拟方法调用
动态绑定：编译时e为Person类型，而方法的调用是在运行时确定的，所以调用的是Sstudent类的showInfo方法。
6.3 多态小结
概念举例
实例变量举例，子类定义age不会对父类中的age进行覆盖
向上转型的情况下，验证了即使父子类中都有age变量。子类也无法覆盖父类，因为变量不具备多态性，编译时为父类类型，使用了父类的构造器，age则为父类定义的14。即可以把父类中的变量转移到子类中。
如果是正常定义Student s = new Student(); s.age则此时age与父类无关，为24。
自我总结：注意关于向上转型的情况下，调用方法和属性的区别
对象的多态：指编译和运行时的类型不一样Person p = new Student();
向上转型：指将子类的对象给父类类型的变量引用。（子类可以看成是特殊的父类）
这种情况下生成的变量不可以访问子类中添加的属性和方法（因为属性是在编译时决定的，编译时为父类类型，没有子类的成员变量）
但调用的方法若子类父类中都有（多态情况下即子类重写的父类的方法），则调用选择的是子类中的方法。因为编译时变量为父类，运行时给变量赋值的对象为子类类型。而方法的调用是在运行时决定的，所以调用的是子类的方法，称为动态绑定
6.4 instanceof操作符
7 Object类
”父类可以自动接收子类实例化对象“这句话就是指父类可以接受子类对象。理解层面：猫、狗都属于动物，Animal a = new Dog();
7.1 Object类中的主要方法
equals
hashCode
toString 打印引用的对象所在的内存地址
7.2 对象类型转换(Casting)
int i=10;
long l = i;
long l1 = 10L;
int i1 = (int)l1;
Student s = new Student();
Person p = s;//从子类到父类的类型转换可以自动进行
Person p2 = new Person();
Student s2 = (Student)p2;//从父类到子类的类型转换必须通过造型(强制类型转换)实现
Test t = new Test();
//p2 = t;//无继承关系的引用类型间的转换是非法的
注意父类到子类的类型转换问题
Person p = new Person();
Student s = (Student)p;//直接这样写会报错
//day08.Person cannot be cast to day08.Student
// at day08.Test.main(Test.java:17)
//需要父类Person进行一次向上转型(Person p = new Student();)之后才可以强制转换，Person p = new Student();
修改后
Person p2 = new Student();
Student s2 = (Student)p2;//从父类到子类的类型转换必须通过造型(强制类型转换)实现
//需要父类Person进行一次向上转型(Person p = new Student();)之后才可以强制转换
//Object是所有类的最高父类
String s = "hello";
Object obj = s;//从子类到父类的类型转换可以自动进行
System.out.println(obj);
Object obj2 = "hello";
String s2 = (String)obj;//父到子，强转
System.out.println(s);
7.3 对象类型转换举例
7.4 ★总结：强制类型转换&自动类型转换
基本数据类型，表数范围小的int为较低级，表数范围大的long为较高级
子类为较低级，父类为较高级，Object类为所有类的最高父类
高级兼容低级，子类看做特殊的父类，低级转高级需要强转。
个人理解：此时的强转都是一种引用的强转，而不是一种实例化后对象的强转
//1.
int i=10;
long l = i;
long l1 = 10L;
int i1 = (int)l1;
//2.
Student s = new Student();
Person p = s;//从子类到父类的类型转换可以自动进行
Person p2 = new Student();
Student s2 = (Student)p2;//从父类到子类的类型转换必须通过造型(强制类型转换)实现
//3.
String s = "hello";
Object obj = s;//从子类到父类的类型转换可以自动进行
System.out.println(obj);
Object obj2 = "haha";
String s2 = (String)obj2;//父到子，强转
System.out.println(s);
复习前文
向上转型：指将子类的对象给父类类型的变量引用。即Person p = new Student();（子类可以看成是特殊的父类）
这种情况下生成的变量不可以访问子类中添加的属性和方法（因为属性是在编译时决定的，编译时为父类类型，没有子类的成员变量）
但调用的方法若子类父类中都有（多态情况下即子类重写的父类的方法），则调用选择的是子类中的方法。因为编译时变量为父类，运行时给变量赋值的对象为子类类型。而方法的调用是在运行时决定的，所以调用的是子类的方法，称为动态绑定
✔ 操作符==与equals方法总结
- ==
int i=0;
long l =0L;
System.out.println(i == l);//true
Person p1 = new Person();
Person p2 = p1;
System.out.println(p1 == p2);//true
System.out.println(p1.equals(p2));//true
p2 = new Person();
System.out.println(p1 == p2);//false
System.out.println(p1.equals(p2));//false
//特殊情况
String s1 = new String("xuexue");
String s2 = new String("xuexue");
System.out.println(s1 == s2);//false
System.out.println(s1.equals(s2));true
- equals()
- 在Java中类型可分为两大类：值类型与引用类型。值类型就是基本数据类型（如int ,double 等），而引用类型,是指除了基本的变量类型之外的所有类型（如通过 class 定义的类型）
结论：
==对于基础数据类型比较内容;对于比较引用类，只有是同一个对象才true- equals只能比较引用对象，普通类对象，只有同为同一个对象才是true
但是对于File,String,Data和包装类， equals是比较内容相等即可，不要求必须是同一个对象- 对于对象来说
特殊的类，如String,File,Date,使用==比较的是对象（对象的地址），
equals比较的是内容
除了特殊的类之外的其它普通的类的对象，==和equals比较的都是对象（对象的内存地址）- 如果想改变某一个类的equals,不想用equals来比较对象的内存地址，就需要重写equals方法
★String对象的创建过程
✔ 练习 1.用equals,==比较变量和对象2.编写Order类，判断同类的两对象是否相等
int it = 65;
float fl = 65.0f;
System.out.println(“65和65.0f是否相等？” + (it == fl)); //true
char ch1 = 'A'; char ch2 = 12;
System.out.println(“65和‘A’是否相等？” + (it == ch1));//true，65是A的ASCII码
System.out.println(“12和ch2是否相等？" + (12 == ch2));//true
String str1 = new String("hello");
String str2 = new String("hello");
System.out.println(“str1和str2是否相等？”+ (str1 == str2));//false，不是同一个对象
System.out.println(“str1是否equals str2？”+(str1.equals(str2)));//true，特殊情况，在String中equals是用来比较值的
System.out.println(“hello” == new java.sql.Date()); //编译不通过，类型不同
Person p1 = new Person();
p1.name = "atguigu";
Person p2 = new Person();
p2.name = "atguigu";
System.out.println(p1.name .equals( p2.name));//true，name属性是字符串
System.out.println(p1.name == p2.name);//true,实际上都是引用的字符串常量池里的同一个字符串
System.out.println(p1.name == "atguigu");//true
String s1 = new String("bcde");
String s2 = new String("bcde");
System.out.println(s1==s2);//false
练习
1.编写Order类，有int型的orderId，String型的orderName，相应的getter()和setter()方法，两个参数的构造器，重写父类的equals()方法：public boolean equals(Object obj)，并判断测试类中创建的两个对象是否相等。
思路：
判断两个order对象的属性都相等就是对象相等，其实就是orderId相等，orderName相等
-
复习，快速生成类的getter和setter方法，还有调用重写父类
alt+ins—>Getter and Setter
按住ctrl同时选择要获得get,set方法的属性
如图自动生成
-
重写父类方法
ctrl+o—>选择equals方法
如图
package day08;
/**
* Created with IntelliJ IDEA.
*
* @Author: xuexuezi
* @Date: 2022/08/06/9:23
* @Description:
*/
public class Order {
int orderId;
String orderName;
public Order(){
orderId = 0;
orderName = null;
}
//两个参数的构造器
public Order(int orderId, String orderName) {
this.orderId = orderId;
this.orderName = orderName;
}
//相应的getter()和setter()方法
public int getOrderId() {
return orderId;
}
public void setOrderId(int orderId) {
this.orderId = orderId;
}
public String getOrderName() {
return orderName;
}
public void setOrderName(String orderName) {
this.orderName = orderName;
}
//重写父类的equals()方法:
@Override
public boolean equals(Object obj) {
//return super.equals(obj);
boolean flag = false;
Order o = new Order();
if(obj instanceof Order){//判断obj是不是order的类或子类
o = (Order)obj;//强转Object类为Order,其中判断时obj所属的类并不是编译时用来接收的Object类，而是实际运行时的对象所属类型
}
if(this.orderId == o.orderId && orderName.equals(o.orderName)){
flag = true;
}
return flag;
}
public static void main(String[] main){
Order o1 = new Order(89,"786df");
Order o2 = new Order(78,"786df");
Order o3 = new Order(78,"786df");
System.out.println(o1.equals(o2));//false
System.out.println(o2.equals(o3));//true
}
}
2.请根据以下代码自行定义能满足需要的MyDate类,在MyDate类中覆盖equals方法，使其判断当两个MyDate类型对象的年月日都相同时，结果为true，否则为false。 public boolean equals(Object o)
package day08;
/**
* Created with IntelliJ IDEA.
*
* @Author: xuexuezi
* @Date: 2022/08/09/21:51
* @Description:
*/
public class MyData {
public MyData(){
}
public MyData(int year, int month, int day){
this.year = year;
this.month = month;
this.day = day;
}
int year;
int month;
int day;
@Override
public boolean equals(Object obj) {
//return super.equals(obj);
int flag = 1;
if(obj instanceof MyData){
MyData m = (MyData)obj;
flag = 0;
if(this.year != m.year) {
flag += 1;
}
if(this.month != m.month){
flag += 1;
}
if(this.day != m.day){
flag += 1;
}
}
return flag == 0? true: false;
//这种写法的flag代表两两比较年月日时，不匹配的次数。0说明三个都相等
}
}
MyData m1 = new MyData(2022,8,9);
MyData m2 = new MyData(2022,8,9);
MyData m3 = new MyData(2022,8,10);
System.out.println(m1.equals(m2));//true
System.out.println(m2.equals(m3));//false
✔ Object类的toString方法
- Object的toString输出
Object的toString方法会返回表示对象值的一个字符串。
绝大多数（但不是全部）的toString方法都遵循这样的格式类的名字，随后是对象的地址散列码
//Object.toString()
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
//String.toString自身就是一个字符串
public String toString() {
return this;
}
MyData m1 = new MyData();
String str = "78hg";
System.out.println(m1.toString());//com.qx.day09.MyData@38cccef
System.out.println(str.toString());//78hg
- 重写toString
要输出类的其他信息，重写toString方法getClass().getName()+"[year="+this.year+",month="+this.month+",day="+this.day;
//MyData的方法
/**
* @Description: 重写Object类的toString方法,使其从输出对象地址到输出对象内容
* @Param: []
* @return: java.lang.String
* @Author: xuexuezi
* @Date: 2022/8/14
*/
@Override
public String toString() {
String str = getClass().getName()+"[year="+this.year+",month="+this.month+",day="+this.day+"]";
//com.qx.day09.MyData[year=0,month=0,day=0]
return str;
}
//调用
MyData m1 = new MyData();
System.out.println(m1);//com.qx.day09.MyData[year=0,month=0,day=0
System.out.println(m1.toString());//com.qx.day09.MyData[year=0,month=0,day=0
System.out.println("m1="+m1);//m1=com.qx.day09.MyData[year=0,month=0,day=0
- toString的自动调用
-
- 直接输出对象，简单调用toString方法
-
- 在进行String类与其他引用类型对象的“+”拼接操作时，自动调用引用类对象的toString()方法，可以不写x.toString，而写作""+x。
-
- 基本数据类型通过“+”拼接转化为String类型时，调用了基础数据类型对应包装类的toString方法
MyData m1 = new MyData();
String str = "78hg";
//1.直接输出对象，简单调用toString方法
System.out.println(m1);//com.qx.day09.MyData@38cccef
//相当于下一行
System.out.println(m1.toString());//com.qx.day09.MyData@38cccef
//2.String类与其他类型的“+”拼接操作,自动调用toString方法
System.out.println("m1="+m1);//m1=com.qx.day09.MyData@38cccef
//相当于下一行
System.out.println("m1="+m1.toString());//m1=com.qx.day09.MyData@38cccef
//String类重写了Object的toString方法，返回的是this
System.out.println(str);//78hg
System.out.println(str.toString());//78hg
System.out.println("str="+str);//78hg
System.out.println("str="+str.toString());//78hg
//3.基本数据类型与String拼接时，调用了对应包装类的toString方法
boolean b = true;
int i = 0;
char c = 'd';
System.out.println("b = "+b);//b = true
//相当于下一行
System.out.println("b = "+new Boolean(b).toString());//b = true
System.out.println("i = "+i);//i = 0
//相当于下一行
System.out.println("i = "+new Integer(i).toString());//i = 0
System.out.println("c = "+c);//c = d
//相当于下一行
System.out.println("c = "+new Character(c).toString());//c = d
✔ 打印数组的方法Arrays.toString,多维数组Arrays.deepToString
char[] arr = {'7','9','j'};
System.out.println(Arrays.toString(arr));//[7, 9, j]
int[][] arr2 = {{3,4,5},{3,5},{9}};
System.out.println(Arrays.deepToString(arr2));//[[3, 4, 5], [3, 5], [9]]
8 包装类
8.1 装箱、拆箱，自动装箱、自动拆箱
//装箱
Integer i = new Integer(111);
Integer i2 = new Integer("123");//字符串参数装箱
//Integer i3 = new Integer("abc");//编译不报错，运行有错
Boolean b = new Boolean("true");//字符串参数装箱
Boolean b2 = new Boolean(false);
//拆箱
int i4 = i.intValue();
int i5 = i2.intValue();
boolean b3 = b.booleanValue();
boolean b4 = b2.booleanValue();
boolean b5 = new Boolean("false").booleanValue();//字符串参数装箱后拆箱
boolean b55 = new Boolean(true).booleanValue();
//自动装箱
Integer i6 = new Integer(78);//装箱
//将上句简化写为
Integer i7 = 78;//自动装箱
Integer i8 = i7;//自动装箱
Integer i8 = new Integer("89");//字符串参数构造包装类对象
//简化写法
//发现数据类型，自动装箱不可以用字符串参数构造
//Integer i9 = "89";//编译不过
Boolean b6 = new Boolean(true);
//简化写法
Boolean b7 = true;//自动装箱
Boolean b8 = new Boolean("false");//字符串参数构造包装类对象
//发现boolean类型，自动装箱不可以用字符串参数构造
//Integer i9 = "89";//编译不过
//Boolean b9 = "false";//编译不过
//自动拆箱
int i10 = i6.intValue();//拆箱
//简化写法
int i11 = i7;//自动拆箱
boolean b9 = b6.booleanValue();//拆箱
//简化写法
boolean b10 = b7;//自动拆箱
boolean b11 = new Boolean("true").booleanValue();//拆箱，PS：装箱过程用的字符串参数
//简化写法
boolean b12 = new Boolean("false");//自动拆箱，PS:装箱过程用的字符串参数
boolean b13 = new Boolean(false);//自动拆箱
✔ 关于在方法中使用时的装箱，以包装类对象.compareTo(包装类对象作为参数)方法为例。其中参数部分可以直接填基本数据类型，会自动装箱
Byte和Short只能用字符串参数，不能用值参数。所以比较时无法用值自动装箱，必须用字符串参数手动装箱后使用。
**Character只能用值参数，不能用字符串参数。可以通过值参数在方法参数部分自动装箱
- 其他5种（
Integer,Long,Float,Double,Boolean）基本数据类型包装类和String类既可以用值参数自动装箱，也可以用字符串参数手动装箱。可以通过值参数在方法参数部分自动装箱 - 需要注意的是
Float和Long在使用字符串参数时，不需要带L,l;F,f
//通过compareTo比较引用类型String类对象的大小
System.out.println("-------------String-------------");
String str1 = "1234y";
System.out.println("sytudf".compareTo("syt"));//3
System.out.println(str1.compareTo("1234y45ttyu"));//-6
//通过compareTo比较基本数据类型的包装类大小
//Byte字节型1字节
//Byte只能用字符串参数装箱，且无法识别整型数据为Byte必须装箱
System.out.println("-------------Byte-------------");
System.out.println(new Byte("12").compareTo(new Byte("124")));//-112
//Short短整型2字节
//Short只能用字符串参数装箱，且无法识别整型数据为Short必须装箱
System.out.println("-------------Short-------------");
System.out.println(new Short("235").compareTo(new Short("345")));//-110
//Integer整型4字节
//Integer可以用值参数装箱，也可以用字符串参数装箱；且值参数自动识别整数数据为int作为参数自动装箱
System.out.println("-------------Integer-------------");
System.out.println(new Integer(45).compareTo(56));//-1
System.out.println(new Integer("3456").compareTo(new Integer("345")));//1
//Long长整型8字节，定义时尾部加L或l
//Long可以用值参数装箱，也可以用字符串参数装箱,用字符串参数时不加L，l；且值参数自动识别整数l数据为Long作为参数自动装箱
System.out.println("-------------Long-------------");
System.out.println(new Long(7845634353543l).compareTo(7856l));//1
System.out.println(new Long("45634").compareTo(34545L));//1;注意：用字符串参数就不用加L
//Float单精度浮点型（小数型）4字节，定义时尾部加f或F
//Float可以用值参数装箱，也可以用字符串参数装箱,用字符串参数时不加F,f；且值参数自动识别小数F，f数据为Float作为参数自动装箱
System.out.println("-------------Float-------------");
System.out.println(new Float(34.67f).compareTo(34.62F));//1
System.out.println(new Float("35.6").compareTo(35.6f));//0
//Double双精度浮点型（小数型）8字节，小数默认是double
//Double可以用值参数装箱，也可以用字符串参数装箱；且值参数自动识别小数数据为Double作为参数自动装箱
System.out.println("-------------Double-------------");
System.out.println(new Double(3456.786).compareTo(3456.756));
System.out.println(new Double("654.345").compareTo(645.345));
//Character字符型，2字节。ASCII码中，1个英文字符占用1个字节，1个汉字字符占用2个字节的空间
//Character可以用值参数装箱，不可以用字符串参数装箱；且值参数自动识别'一个字符'数据为Chacter作为参数自动装箱
System.out.println("-------------Character-------------");
System.out.println(new Character('y').compareTo(new Character('y')));//0
System.out.println(new Character('8').compareTo('9'));//-1
System.out.println(new Character('1').compareTo('A'));//-16
//Boolean布尔型1字节
//Boolean可以用值参数装箱，可以用字符串参数装箱；且值参数自动识别true或false数据为Boolean作为参数自动装箱
System.out.println("-------------Boolean-------------");
System.out.println(new Boolean(false).compareTo(true));//-1
System.out.println(new Boolean("true").compareTo(new Boolean("true")));//0
8.2 ★字符串转换成基本数据类型，基本数据类型转换为字符串
//把字符串转化成基本数据类型
int i = Integer.parseInt("123");
//我的感觉可以这样替换写
int i2 = new Integer("123").intValue();//用字符串参数装包后拆包
int i3 = new Integer("456");//用字符串参数装包后，通过直接赋值进行自动拆包
float f = Float.parseFloat("0.40");
boolean b = Boolean.parseBoolean("false");
System.out.println(i+","+i2+","+i3+","+f+","+b);
//基本数据类型转化为字符串
String istr = String.valueOf(98);
String istr2 = String.valueOf(i);
String fstr = String.valueOf(8.9);
String fstr2 = String.valueOf(f);
String bstr = String.valueOf(true);
String bstr2 = String.valueOf(b);
System.out.println(istr+","+fstr+","+bstr);
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
