面向对象学习day15

已于 2022-04-12 21:29:09 修改
阅读量411 收藏
点赞数 1
文章标签： java
于 2022-04-12 00:14:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47599156/article/details/124112981
版权
本文详细介绍了Java中的Object类基础，包括其作用、构造器和常用方法如equals()与toString()的原理与重写规则。此外，还对比了==和equals()的区别，展示了基本数据类型和包装类在equals()中的行为。
摘要由CSDN通过智能技术生成

java面向对象学习day15

无论当下的境遇如何，这片大陆的星空下始终都有你的位置。

一、Object类

1、说明：

  • Object类是所有Java类的根父类

  • 如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object

  • Object类中的功能（属性、方法）就具有通用性

  • Object类只声明了一个空参的构造器

  • 方法：equals()、toString()、getClass()、hashCode()、clone()、finalize()、wait()、notify()、notifyAll()

2、面试题：

final、finally、finalize的区别？

二、equals

1、面试题： == 和 equals() 区别

1.1 “==”的使用：

  • 如果比较的是基本数据类型变量：比较的是两个变量保存的数据是否相等。(不一定要类型相同)

  • 如果比较的是引用数据类型变量：比较两个变量的地址值是否相等。即，两个引用是否指向同一个对象实体

  • “==”符号使用时，必须保证符号左右两边的变量类型一致。

1.2“equals()”的使用：

  • 是一个方法，而非运算符。因此，只适用于引用数据类型。

  • Object类中equals()源码中的定义：

    public boolean equals(Object obj) { ​ return (this == obj); ​ }

    注：Object类中定义的equals的作用是相同的：比较两个对象的地址值是否相同。

  • 像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后，比较的不是两个引用的地址是否相同。而是比较两个对象的“实体内容”是否相同。

  • 通常情况下，完美自定义的类如果使用equals()的话，通常是比较两个对象的”实体内容“是否相同。那么我们就需要对Object类中的equals()进行重写。重写的原则：比较两个对象的实体内容是否相同

1.3 重写equals()方法的原则

2、实例

 package Object.day15.Test;
 import Object.day15.Customer;
 import java.util.Date;
 public class EqualsTest {
     public static void main(String[] args) {
 ​
         //基本数据类型
         int i = 9;
         int j = 9;
         double d = 9.0;
         System.out.println(i == j);
         System.out.println(i == d);
 ​
         boolean b = true;
         //System.out.println(boolean == i);//编译报错
 ​
         char c = 9;
         System.out.println(i == c);//true
 ​
         //引用数据类型
         Customer cust1 = new Customer("jay",22);
         Customer cust2 = new Customer("jay",22);
         System.out.println(cust1 == cust2);//false
 ​
         String str1 = new String("nihaoya");
         String str2 = new String("nihaoya");
         System.out.println(str1 == str2);//false
 ​
         System.out.println(cust1.equals(cust2));//false
         System.out.println(str1.equals(str2));//true
 ​
         Date date1 = new Date(2342422424L);
         Date date2 = new Date(2342422424L);
         System.out.println(date1.equals(date2));//true
 ​
     }
 }

三、toString()

1、Object类中toString()的使用

  • 当我们输出一个对象的引用时，实际上就是调用当前对象的toString()

  • Object类中toString()定义的源码：

    public String toString() { return getClass().getName() + "@" + Integer.toHexString(hashCode()); }

  • 像String、Date、File、包装类等都重写了Object类中的toString()方法。使得在调用对象的toString()时，返回“实体内容”信息

  • 自定义类也可以重写toString()方法，当调用此方法时，返回对象的“实体内容”

四、包装类（Wrapper）

1、包装类的使用

  • java提供了8种基本数据类型对应的包装类，使得基本数据类型的变量具有类的特征。

  • 掌握的：基本数据类型、包装类、String之间的相互转换

2、概述

3、基本数据类型、包装类和String类间的转化

重点：

  • 基本数据类型和包装类之间可自动装箱与自动拆箱

  • 基本数据类型和包装类转化成String类利用String重载的 valueOf() 方法

  • String转化成基本数据类型和包装类利用包装类的parseXxx(String)方法

实例：

 
package Object.day15;
 import org.junit.Test;
 public class WrapperTest {
 ​
 //String类型 --->基本数据类型、包装类型:调用包装类的parseXxx(String s)
     @Test
     public void test5(){
         String str1 = "123";
         int num2 = Integer.parseInt(str1);
         System.out.println(num2 + 1);
 ​
         String str2 = "true";
         boolean b1 = Boolean.parseBoolean(str2);
         System.out.println(b1);
 ​
         String str3 = "true1";//不是标准的true都是false
         boolean b2 = Boolean.parseBoolean(str3);
         System.out.println(b2);
     }
 ​
 //基本数据类型、包装类 --->String类型:调用String重载的valueOf()
     @Test
     public void test4(){
 ​
         int num1 = 10;
         //方式1：连接运算
         String str1 = num1 + "";
         //方式2：调用String的valueOf(xxx)
         float f1 = 12.3f;
         String str2 = String.valueOf(f1);
         System.out.println(str2);
         Double d1 = new Double(12.3);
         String str3 = String.valueOf(d1);
         System.out.println(str3);
 ​
     }
 ​
     //JDK 5.0新特性：自动装箱与自动拆箱
     @Test
     public void test3(){
         int num1 = 10;
         method(num1);
     }
 ​
     public void method(Object obj){
         System.out.println(obj);
     }
 ​
 //包装类 ---> 基本数据类型 : 调用xxxValue()
     @Test
     public void test2(){
         Integer in1 = new Integer(12);
         int i1 = in1.intValue();
         System.out.println(i1 + 1);
 ​
         Float f1 = new Float(12.3);
         float f2 = f1.floatValue();
         System.out.println(f2);
 ​
     }
 ​
 //基本数据类型 ---> 包装类 : 调用包装类的构造器
     @Test
     public void test1(){
 ​
         int num1 = 10;
         Integer in1 = new Integer(num1);
         System.out.println(in1.toString());
 ​
         Integer in2 = new Integer("12345");
         System.out.println(in2.toString());
 ​
 //        报异常(里面必须为int类型)
 //        Integer in3 = new Integer("12345abc");
 //        System.out.println(in3.toString());
 ​
         Float f1 = new Float(12.3);
         Float f2 = new Float("12.4");
         System.out.println(f1);
         System.out.println(f2);
 ​
         Boolean b1 = new Boolean(true);
         Boolean b2 = new Boolean("TrUe");
         System.out.println(b2);
         Boolean b3 = new Boolean("true123");
         System.out.println(b3);
 ​
         Order1 order1 = new Order1();
         System.out.println(order1.isMale);
         System.out.println(order1.isFemale);
 ​
     }
 ​
 }
 ​
 class Order1{
     boolean isMale;
     Boolean isFemale;
 }

3、包装类相关面试题

题一：下面两者的输出分别什么？

 
@Test
 public void test1(){
     Object o1 = true ? new Integer(1) : new Double(2.0);
     System.out.println(o1);
 }
 ​
 @Test
 public void test2(){
     Object o2;
     if(true)
         o2 = new Integer(1);
     else
         o2 = new Double(2.0);
     System.out.println(o2);
 }

result：

1.0

1

analyze：

三元运算符的右边两个选项的类型必须相同。而上述例子中左边为int类型，而右边为double类型。故会先将左边的int类型自动转化为double，即1.0。转化完成后再执行三元运算符。故最终输出的结果为1.0。（坑爹呀）

题二：下面程序输出的结果为？

 Integer i = new Integer(1);
 Integer j = new Integer(1);
 System.out.println(i == j);//true
 ​
 Integer m = 1;
 Integer n = 1;
 System.out.println(m == n);
 ​
 Integer x = 128;
 Integer y = 128;
 System.out.println(x == y);

result：

analyze：

Integer内部定义了IntegerCache结构，IntegerCache中定义了Integer[ ]，保存了从-128~127范围的整数。如果我们使用自动装箱的方式，给Integer赋值的范围在-128~127范围内时，直接使用了数组中的元素，不用再去new了。若超出这个范围，则需去new对象。目的：提高效率

Examples

test1：

topic：

 

code：

GeometricObject：

 
package Object.day14.Test;
 ​
 public class GeometricObject {
 ​
     protected String color;
     protected double weight;
 ​
     public GeometricObject(){
 ​
     }
     protected GeometricObject(String color,double weight){
         this.color = color;
         this.weight = weight;
     }
 ​
     public void setColor(String color){
         this.color = color;
     }
     public String getColor(){
         return color;
     }
 ​
     public void setWeight(double weight){
         this.weight = weight;
     }
     public double getWeight(){
         return weight;
     }
 ​
     public double findArea(){
         return 0.0;
     }
 ​
 }

Circle：

 
package Object.day14.Test;
 ​
 public class Circle extends GeometricObject{
 ​
     private double radius;
 ​
     public Circle(double radius,String color,double weight){
         super(color,weight);
         this.radius = radius;
     }
 ​
     public void setRadius(double radius){
         this.radius = radius;
     }
     public double getRadius(){
         return radius;
     }
 ​
     public double findArea(){
         return Math.PI * radius * radius;
     }
 }

MyRectangle：

 
package Object.day14.Test;
 ​
 public class MyRectangle extends GeometricObject{
 ​
     private double width;
     private double height;
 ​
     public MyRectangle(double width,double height,String color,double weight){
         super(color,weight);
         this.width = width;
         this.height = height;
     }
 ​
     public void setWidth(double width){
         this.width = width;
     }
     public double getWidth(){
         return width;
     }
 ​
     public void setHeight(double height){
         this.height = height;
     }
     public double getHeight(){
         return height;
     }
 ​
     public double findArea(){
         return width * height;
     }
 ​
 }

GeometricTest：

 package Object.day14.Test;
 ​
 public class GeometricTest {
 ​
     public static void main(String[] args) {
         GeometricTest test = new GeometricTest();
         Circle c1 = new Circle(2.0,"red",3.0);
         test.displayGeometricObject(c1);
         Circle c2 = new Circle(3.0,"blue",7.0);
         test.displayGeometricObject(c2);
 ​
         System.out.println(test.equalsArea(c1, c2));
     }
 ​
         public boolean equalsArea(GeometricObject o1,GeometricObject o2){
             return o1.findArea() == o2.findArea();
         }
 ​
         public void displayGeometricObject(GeometricObject o3){
             System.out.println("面积为：" + o3.findArea());
         }
 ​
 ​
 ​
 }

result：

test2：

code：

package Object.day15.Test.test1;

public class test {
    public static void main(String[] args) {
        Base1 base = new Sub1();
        base.add(1,2,3);
        Sub1 s = (Sub1)base;
        s.add(1,2,3);
    }
}

class Base1{
    public void add(int a,int... arr){
        System.out.println("base1");
    }
}

class Sub1 extends Base1{
    public void add(int a,int[] arr){
        System.out.println("sub1");
    }

    public void add(int a,int b,int c){
        System.out.println("sub2");
    }
}

result：

analyze：

首先子类Sbu1继承于父类Base1。而利用多态性，创建了base对象。在调用add方法时，发现子类重写了add方法，子类将父类的add方法覆盖。所以base调用的为子类重写的方法。即第一个输出语句为“sub1”。

而后面又将base强制转型成了Sub1类型，此时调用add方法时，便优先考虑形参为三个的后者方法。即第二个输出语句为“sub2”

        

        今天也是看到几句很棒的话：

        1、平凡的好处，在于身边处处都是你的参照物。处处都是理解你的人

        2、无论当下的境遇如何，这片大陆的星空下始终有你的位置

        3、旋涡无法击碎的磐石，也终将会在时光的冲刷下磨损。

飘落的枫叶像思念
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java面向对象程序设计
02-19
通过本次实验，学习者能够深入理解面向对象的基本概念，并掌握了Java语言中面向对象编程的主要技术。这些技术包括但不限于类的设计、对象的创建、封装性、继承、多态以及接口的使用等。此外，还通过具体的编程实践...
java多态的练习 ,定义三个类，父类GeometricObject代表几何形状，子类Circle代表圆形，MyRectangle代表矩形。 定义一个测试类GeometricTest，编写equals
YingxueSec
02-01 7179
定义三个类，父类GeometricObject代表几何形状，子类Circle代表圆形，MyRectangle代表矩形。 定义一个测试类GeometricTest，编写equalsArea方法测试两个对象的面积是否相等（注意方法的参 数类型，利用动态绑定技术），编写displayGeometricObject方法显示对象的面积（注意方法的参 数类型，利用动态绑定技术）。 代码实现 public class GeometricObject {//几何图形 private String color;
Java面试题(持续更新)
编程怪的博客
06-13 180
关于多态 public class Test1{ public static void main(String[] args){ //1.运行结果为? Base1 base =new Sub1(); base.add(1,2,3); //2.运行结果为? Sub s = (Sub)base; s.add(1,2,3); //3.去掉注解运行结果为 Base1 base =new Sub1(); base.add(1,2,3); } } class Base1{ pu
Java 面向对象（中）2 —— Object类、包装类
Algo_x的博客
06-15 490
1 Object类 1.1 面试题： == 和 equals() 区别 /* * 一、回顾 == 的使用： * == ：运算符 * 1. 可以使用在基本数据类型变量和引用数据类型变量中 —— 两种变量都适用 * 2. 如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等。（不一定类型要相同） * 如果比较的是引用数据类型变量：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体 * 补充： == 符号使用时，必须保证符号左右两边的变量类型一致。 * 二、equa...
多态——动态绑定(实验)
qq_39237781的博客
10-01 5179
定义三个类，父类GeometricObject代表几何形状，子类Circle代表圆形，MyRectangle代表矩形。 定义一个测试类Test，编写equalsArea方法测试两个对象的面积是否相等（注意方法的参数类型，利用动态绑定技术），编写displayGeometricObject方法显示对象的面积（注意方法的参数类型，利用动态绑定技术） 这里先给出GeometricObject类 pac...
Java学习路线：day15
12-20
文章目录第四章 面向对象(下)抽象类与抽象方法抽象类应用练习创建抽象类的匿名子类对象多态的应用：模板方法设计模式(TemplateMethod)抽象类的练习接口(interface)概述举例接口的应用：代理模式(Proxy)接口的应用：...
day07-面向对象1
08-04
1.4 封装【概念与实现】封装是面向对象编程的核心特性之一，它将数据和操作数据的方法绑定在一起，作为一个相互依赖的整体——对象。封装的目的是隐藏对象的属性和实现细节，仅对外提供公共访问方式。实现封装的步骤...
day06 01 面向对象思想的概述
08-31
day06_01_面向对象思想的概述
day06 02 面向对象思想的举例
08-31
day06_02_面向对象思想的举例
刷题02
FunnyPrince_的博客
04-07 281
利用Vector代替数组处理，从键盘读入学生成绩(以负数代表输入结束)，找出最高分，并输出学生成绩等级。 提示:数组一旦创建，长度就固定不变，所以在创建数组前就需要知道它的长度。 而向量类java. util . Vector可以根据需要动态伸缩。 创建Vec cter对象: Vector v=new Vector(); 给向量添加元素: v. addElement(object obi); / /obj必须是对象 取出向量中的元素: object obj=v. elementAt(0); 注意第一个元素的
Java——抽象类GeometricObject
热门推荐
TFBOYS_3的博客
04-08 1万+
（仅记录个人的学习之路） 本题目涉及的知识点： 类的继承：Triangle类和Rectangle类，其父类为GeometricObject； 方法覆盖：Triangle类和Rectangle类覆盖了父类GeometricObject的getArea()方法和getPerimeter()方法； 父类GeometricObject为抽象类，定义了抽象方法getArea()和getPerimeter(...
尚硅谷java入门(303p- 346p)2022.3.17 面向对象(下）
qq_46272491的博客
03-17 921
303p 基本数据类型转换为包装类 public class WrapperTest{ //String类型--->基本数据类型，包装类：调用包装类的parseXxx（） @Test public void test5(){ String str1="123"; //Interger in1=(Integer)str1; //可能会报NumberFormatExpection int num2=Integer.parseInt(str1); System.out.println
GeometricObject
u014757261的专栏
05-05 1305
public class GeometricObject{     private String color = "white";     private boolean filled;     private java.util.Date dateCreated;         /** Construct a default geometric object */     pub
抽象类和接口
yongchaocsdn的博客
11-30 2932
抽象类在继承的层次结构中,随着每个新子类的出现,类会变得越来越来明确和具体.如果从一个子类追溯到父类,类就会变得更通用,更加不明确.类的设计应该确保父类包含他的子类的共同特征.有时候,一个父类设计得非常抽象,以至于他都没有任何具体的实例.这样的类称为抽象类 GeometricObject类定义成Circle和Rectangle类的父类.GeometricObject类模拟了几何对象的共同特征.Ci
spring事务详细讲解-深入浅出
小电玩
09-08 431
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1431
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
JAVA基础：数据类型、命名规范
weixin_53755148的博客
09-05 1361
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
Java集合：Stack详解
最新发布
yang_brother的博客
09-10 460
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
Java学习：面向对象与类对象详解
"java学习day06" 在Java编程语言中，面向对象编程是核心概念之一。面向对象编程（Object-Oriented Programming, OOP）基于类和对象的概念，旨在通过模拟现实世界中的实体来创建软件模型。在这个示例中，我们看到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值