Java面向对象

NINI121906

于 2023-07-18 22:08:08 发布

阅读量81

点赞数

文章标签： java 开发语言 jvm

本文链接：https://blog.csdn.net/m0_64392175/article/details/131797463

版权

一、object equals

Object : 类是java中所有类的父类（老祖宗类)

如果一个类没有显示的继承自其他类,默认继承自Object

在java中所有的类都会继承自Object类,因为不是直接继承,就是间接继承

toString : 返回对象的字符串表现形式

来自于Object类中toString方法的实现 :

public String toString() {

return getClass().getName() + "@" + Integer.toHexString(hashCode()); } 当在java中输出一个对象的引用时候,默认输出的是对象调用了toString方法的

返回值结合业务,希望输出一个对象的引用时候,想要输出的是这个对象的所有属性

值,而非地址值

以后在定义实体类的时候,都应该根据所有的属性重写toString方法

equals:比较两个对象是否相等

equals与==的区别：

相同点：都比较是否相同，返回值都是boolean

不同点：

1.比较数据的类型不同

==比较基本数据类型的数据值引用数据类型的对象

eqauls比较引用数据类型的对象数据

2.比较的内容不同

==基本数据类型的数据值是否相等引用数据类型的对象的地址值

      equals：来自于Object类中的equals默认的实现是比较对象的地址值
                    public boolean equals(Object obj) {
                        return (this == obj);
                    }

！！如果在使用equals方法比较对象时候,不想要比较地址,想要比较内容(属性

值)--->在子类中进行重写

public class Equals0001 {
    public static void main(String[] argd){
        Teacher t1=new Teacher("TR",23);
        Teacher t2=new Teacher("QW",25);
        System.out.println(t1==t2);//
        System.out.println(t1.equals(t2));
    }
}
class Teacher{
    private String name;
    private int age;

    public Teacher(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public boolean equals(Object obj){
        if(this==obj){
            return true;
        }
        if(obj instanceof Teacher){//判断obj是否为Teacher类型
            Teacher t=(Teacher)obj;//将obj实参传给t
            if(this.name.equals(t.name)&&this.age==t.age){
                return true;
            }
        }
        return false;
    }
}

实体类的定义规范 | Javabean类的定义规范（Javabean类是一种特殊的Java

类，用于封装数据和提供对数据的访问方法。它通常是一个简单的POJO（Plain

Old Java Object），即一个没有任何限制和约束的普通Java对象。）:

1.类是公共的

2.至少提供一个空构造,根据需求提供带参

3.属性私有化,提供一对公共的访问方式

4.根据所有属性值重写toString方法与equals方法o

二、多态

面向对象的三大特征封装，继承，多态

多态：一种事物的多种形态|多种表现形式|多种实现方式 --> 一个功能不同实现形式

多态的前提：类的继承 |接口的实现

多态的最终体现 : 父类的引用指向子类对象

对应类型引用调用 : 能调用的成员包含,子类中定义的成员 + 父类中的继承的成员

如果子类中存在重写方法,调用子类中重写后的方法对父类的方法进行屏蔽

多态引用调用 : 调用成员变量 : 编译运行找父类|看左边|看类型

调用成员方法 : 编译看父类|左边|类型,运行找子类|右边|对象

多态引用对子类新增成员不可见,但是如果子类中存在方法重写,会调用重写后的方法

public class Ploy001 {
    public static void main(){
        Person001 p=new Student002();//多态
        p.gongNeng();
    }
}
class Person001{
     String name;
     public void gongNeng(){
         System.out.println("这是一个父类语句");
     }
}
class Student002 extends Person001{
    String name;
    public void gongNeng(){
        System.out.println("这是一个子类语句");
    }
}

！！注意 : 如果使用多态但是不配合方法的重写,多态就没有意义

三、引用数据类型转换

标准赋值：对应类型的数据赋值给对应类型的变量 int i = 1; Person p = new Person();

基本数据类型的类型转换：

自动类型提升：小——>大 long l=i；

强制类型转换：大——>小 int i2=（int）l；

引用数据类型的转换：

向上转型：小——>大 Person p=new Student(); 多态

向下转型: 大——>小 Student s=（Student）p；

java.lang.ClassCastException : 类型转换异常

避免类型转换异常的出现 :instanceof 运算符

instanceof语法:引用instanceof类型判断前面的引用是否是指向后面类型的对象|子类对象,如果是返回true,不是返回false

public class Cast {
    public static void main(String[] args){
        //向上转换
        FuClass F=new ZiClass();
        //向下转换
        //ZiClass s=(ZiClass) F;
        //通过多态引用子类新增的成员时候，需要先发生向下转型，然后再调用
        if(F instanceof Brother01){
            Brother01 z=(Brother01) F;  //Brother z=new ZiClass();
            z.test();
        }else if(F instanceof ZiClass){
            ZiClass z=(ZiClass) F;//ZiClass s=(ZiClass) F;
            z.test();
        }
        //jdk14预览，jdk16正式版：将判断与转型两布并成为一步
       
    }
}
class FuClass{

}
class ZiClass extends FuClass{
    public void test(){
        System.out.println("zi类新增成员方法");
    }
}
class Brother01 extends FuClass{
    public void test(){
        System.out.println("br类新增成员方法");
    }
}

四、abstract抽象的

abstract修饰类：抽象类

应用场景 : 1)想要包含定义抽象方法 2)当前类不能实例化

abstract修饰方法：抽象方法没有方法体，存在于方法类中

！！abstract注意：

1.抽象类不能实例化

2.抽象类中可以包含属性,功能,静态,非静态的,抽象的,构造器...

3.抽象类的使用 :

可以根据抽象类类名调用类中的静态内容

可以根据抽象类的具体子类对象,调用成员具体子类 : 重写所有抽象方法 + 按需新增

抽象子类 : 按需重写 + 按需新增

4.抽象方法一旦被重写一次,后续可以按需重写

5.abstract不能与private,final,static,native不能一起使用的

6.抽象类也是类,可以发生多态

public class Abstract001 {
    public static void main(String[] args){
        Abs s=new Abs();
        s.test();
        s.test2();
        s.test3();
        Abstract002 te=new Abs();
        te.test();
        te.test2();
    }

}
 abstract  class Abstract002{
    public abstract void test();
    public void test2(){
        System.out.println("父类");
    }
}
class Abs extends Abstract002{
    public  void test(){
        System.out.println("重写");
    }
    public void test3(){
        System.out.println("，，");
    }

}