JAVA教程从入门到精通 Day11

最新推荐文章于 2024-07-14 22:26:46 发布

dlogcs

最新推荐文章于 2024-07-14 22:26:46 发布

阅读量618

点赞数

文章标签： java 开发语言 java-ee

本文链接：https://blog.csdn.net/dlogcs/article/details/123539330

版权

5.21 Object

Object：老祖宗类 是java中所有类的父类

如果一个类没有显示的继承父类,默认继承自object类

⑴ toString

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

public String toString( ) {

return getClass().getName() + “@” + Integer.toHexString(hashCode());}

当输出一个对象的引用的时候输出的是对象的引用调用toString方法的返回值 ==> 默认调用toString

为什么要在子类中重写toString方法:

因为输出对应的引用时候不想打印对象的地址值想要输出对象的所有属性值对从object中继承的tostring满意

对toString实现不满意在子类中重写tostring

注意:

当定义javabean类型规范都需要重写toString

package wang01;

public class Over {
    public static void main(String[] args) {
        Student sc=new Student("汪超",22,2018012381);
        System.out.println(sc);
        System.out.println(sc.toString());
    }
}


package wang01;

class Student{
    String name;
    int age;
    int num;

    public Student(){}

    public Student (String name,int age,int num){
        this.name=name;
        this.age=age;
        this.num=num;
    }

    public String toString(){
        return (name+","+age+","+num);
    }
}

⑵ equals

== : 比较两个数据是否相等

基本: 比较的是数据值
引用: 比较的是对象地址值

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

object类中的equals方法:默认比较对象的地址值

public boolean equals(Object obj) {

return (this == obj);}

为什么要子类中重写equals方法:

使用object类的equals方法默认比较对象地址业务需求想要比较根据对象的属性值比较是否相等可以在子类

中根据需要重写equals 实现比较对象所有属性而非地址值

注意:

javabean的定义规范：

1.类是公共的

2.属性私有化

3.至少提供一个空构造

4.公共的访问方式

5.重写equals与toString方法

package wang01;

public class Over {
    public static void main(String[] args) {
        Student sc=new Student("汪超",22,2018012381);
        Student ss=new Student("汪超",22,2018012381);
        System.out.println(sc);
        System.out.println(sc.toString());
        System.out.println(sc.equals(ss));
    }
}

package wang01;

class Student{
    String name;
    int age;
    int num;

    public Student(){}

    public Student (String name,int age,int num){
        this.name=name;
        this.age=age;
        this.num=num;
    }

    public String toString(){
        return (name+","+age+","+num);
    }

    public boolean equals(Object obj){
        //增强程序健壮性判断
        if(this==obj){
            return true;
        }
        //两个对象 this obj
        //向下转型
        if (obj instanceof Student){
            Student s=(Student)obj;
            //两个对象：this s
            return this.num == s.num && this.age == s.age && this.name.equals(s.name);
        }
        return false;
    }
}

5.22 抽象类

abstract 抽象的

**抽象类：**被abstract修饰的类

**抽象方法：**被abstract修饰的方法【具有抽象方法的类一定为抽象类】

没有方法体
必须存在与抽象类中

**需求：**定义开发部门不同职位工作内容

开发部门 Develop --> work()

java攻城狮: work–>后端开发

web程序猿:work–>前端开发

注意∶

① 抽象类不能实例化

② 抽象方法必须存在与抽象类中

③ 抽象类中可以定义也可以不定义抽象方法可以定义任意内容

④抽象类的使用：

具体子类对象调用成员
- 重写所有的抽象方法＋按需新增
抽象子类
按需重写 + 按需新增

⑤ 抽象方法必须被重写的 但是只需要重写一次按需重写多次

⑥abstract 不能与private final static native 一起使用

package wang01;

public class Over {
    public static void main(String[] args) {
//        抽象类不能实例化
//        Develop ss=new Develop();
        Java sc=new Java();
        sc.sleep();
        sc.work();
    }
}

//父类
abstract class Develop{
    //work sleep方法体中不知道怎么写 不知道写什么
    public abstract void work();
    public abstract void sleep();
	
    //也可以定义其他内容
    public void test(){
        System.out.println("666");
    }
}

//具体子类
class Java extends Develop{

    @Override
    public void work() {
        System.out.println("工作使我快乐！！！");
    }

    @Override
    public void sleep() {
        System.out.println("睡觉嘎嘎香！！！");
    }
}

5.23 接口

接口:

① 引用数据类型

② 特殊的抽象类【抽象类还提供某些具体实现，接口不提供任何实现，接口中所有方法都是抽象方法】

③ 接口为功能的集合一般为抽象功能的集合

④ class定义类 interface定义接口

⑤ 类只能单继承接口多实现

⑥ 继承与实现非常像

子类继承父类有权直接使用父类的成员可以不重写直接使用
实现类实现一个接口拥有了接口中的功能但是都为抽象功能需要实现类自己重写侧重点关注的重写

⑦ 定义开发规范

⑧ 实现解耦降低耦合度

1、接口的定义与使用

语法:

jdk1.7及之前
- 公共的静态的常量 : public static final 任意省略
- 公共的抽象的方法 : public abstract 任意省略
jdk1.8及之后
- 见代码下方

使用:

① 接口不能实例化

② 需要通过实现类进行实现 implements

③ 使用: 通过具体的实现类对象调用

具体实现类 : 重写所有的抽象方法 + 按需新增
抽象实现类 : 按需重写 + 按需新增

需要具体的子类继承重写抽象方法

④ 接口可以多实现,类只能单继承

⑤ 一个类先继承父类,后实现接口

⑥ 类与接口之间 : 只能类实现接口多实现的关系

⑦ 接口与接口之间 : 只能继承不能实现一个接口可以多继承其他接口

package wang;

public class Interface {
    public static void main(String[] args) {
        Imp sc=new Imp();
        sc.test1();
        sc.test4();
        sc.test2();
        sc.test3();
        sc.test5();
    }
}

//接口
interface MyInterface{
    //公共的静态的常量
    double PI=3.14;
    //公共的抽象的方法
    void test1();
    void test2();
}

//具体实现类
class Imp extends Object implements MyInterface,D{

    @Override
    public void test1() {
        System.out.println("6666");
    }

    @Override
    public void test2() {
        System.out.println("7777");
    }

    @Override
    public void test3() {
        System.out.println("8888");
    }

    @Override
    public void test4() {
        System.out.println("9999");
    }

    @Override
    public void test5() {
        System.out.println("3333");
    }
}

//抽象实现类
abstract class Imp2 implements MyInterface{
    public void test1() {

    }
}

interface A{
    void test3();
}

interface B{
    void test4();
}

interface C{
    void test5();
}

interface D extends A,B,C{

}

jdk1.8及之后
- 静态方法 : 被static关键字修饰的方法
通过接口名调用
- 默认方法 : 被default关键字修饰的方法

通过实现类对象调用

package wang;

public class Interface {
    public static void main(String[] args) {
        //静态方法
        MyInterface.testStatic();

        //实现类对象调用
        Imp sc=new Imp();
        sc.testDefault();
    }
}

interface MyInterface{
    //静态方法
    public static void testStatic(){
        System.out.println("静态方法！！！");
    }
    //默认方法
    public default void testDefault(){
        System.out.println("默认方法！！！");
    }
}

//实现类
class Imp implements MyInterface{

}