• 五、java面向对象编程_3


    目录

    十五、Object类

    1.toString

    2.equals

    十六、对象转型(casting)

    十七、动态绑定(多态)

    十八、抽象类(abstract)

    十九、final关键字

    二十、接口

    十五、Object类

    Object类是所有java类的根基类

    如果在类的声明中未使用extends关键字致命其基类,则默认基类为Object类,也就是说

    public class Person {…}等价于public classPerson extends Object {…}

    1.toString

    Object类中定义有public String tuString()方法,其返回值是String类型,描述当前对象的有关信息

    在进行String与其他类型数据的链接操作时(如:System.out.print(“info”+person)),将自动调用该对象类的toString()方法

    可以根据需要在用户自定义类型中重写toString()方法

    //测试类
    public class Test {
        public static void main(String[] args) {
            Dog d = new Dog();
            System.out.println("d: "+d);
            //等价于
             System.out.println("d: "+d.toString());
        }
    }
    class Dog {    
    }

    输出结果:

    d: jian_study.Dog@2a139a55
    d: jian_study.Dog@2a139a55

    如果对于Object中某些方法不满意可以自己在自己类中进行重写,例如:

    public class Test {
        public static void main(String[] args) {
            Dog d = new Dog();
            System.out.println("d: "+d);
            //等价于
            System.out.println("d: "+d.toString());
        }
    }
    class Dog {    
        public String toString(){
            return "HelloWorld!";
        }
    }
    //输出结果
    d: HelloWorld!
    d: HelloWorld!

    2.equals

    public boolean equals(Object obj)方法

    提供定义对象是否相等的逻辑,使用格式:

    x.equals(y)当x和y是同一个对象的应用时返回true,斗则返回false

    jdk提供的一些类,如String,Date等,重写了OBject的equals方法,调用这些类的equals方法,x.equals(y),当x和y所引用的对象是同一类对象且属性能容相等时(并不一定是相同对象),返回true,否则返回false

    可以根据需要在用户自定义类型中重写equals方法

    public class Test {
        public static void main(String[] args) {
            Dog d1 = new Dog();
            Dog d2 = new Dog();
            
            System.out.println(d1 == d2);
            System.out.println(d1.equals(d2));
            
        }
    }
    class Dog {    
    }

    输出结果:

    false
    false

    可以查看javaAPI文档来查看输出为false的原因,这个时候就可以进行方法重写

    public class Test {
        public static void main(String[] args) {
            Dog d1 = new Dog();
            Dog d2 = new Dog();
            
            System.out.println(d1 == d2);
            System.out.println(d1.equals(d2));
            
        }
    }
    class Dog {    
        public boolean equals(Object obj) {
            return true;
        }
    }

    再来看返回结果

    false
    true

    这里只是说明系统方法也是可以重写的,并且进行了一个简单的举例

    十六、对象转型(casting)

    一个基类的引用类型变量可以“指向”其子类的对象

    一个基类的引用不可以访问其子类对象新增的成员(属性和方法)。

    可以使用引用变量instanceof类名来判断该引用型变量所指向的对象是否属于该类或该类的子类

    子类的对象可以当作基类的对象来使用称作向上转型(upcasting),反之称为向下转型(downcasting)

    先看一个例子:

    //新建一个基类
    public class Animal {
        public String name;
        Animal(String name) {
            this.name = name;
        }
    }
    //新建一个子类Cat继承Animal基类
    public class Cat extends Animal {
        public String eyesColor;
        Cat(String n, String c) {
            super(n);
            eyesColor = c;
        }
    }
    //新建一个子类Dog继承基类Animal
    public class Dog extends Animal{
        public String funColor;
        Dog(String n,String c) {
            super(n);
            funColor = c;
        }
    }
    //测试类1
    public class Test {
        public static void main(String args[]) {
            Animal a = new Animal("name");
            Cat c = new Cat("catname","blue");
            Dog d = new Dog("dogname", "black");
            //a的引用是否指向Animal
            System.out.println(a instanceof Animal);//true
            //c的引用是否指向Animal
            System.out.println(c instanceof Animal);//true
            //d的引用是否指向Animal
            System.out.println(d instanceof Animal);//true
            //a的引用是否指向Cat
            System.out.println(a instanceof Cat);//false
            // 父类引用指向子类对象,所以父类无法调用子类的furname属性,所以会报错
            a = new Dog("bigyellow","yellow");
            System.out.println(a.name);//bigyellow
            //System.out.println(a.furname);//error
            //a的引用知否指向Animal
            System.out.println(a instanceof Animal);////true
            //a的引用是否指向Dog,因为instanceof探测的是你实际当中是个什么类型,所以这里会返回true
            System.out.println(a instanceof Dog);//true
            //强制类型转换,所以下面会返回true
            Dog d1 = (Dog)a;
            System.out.println(d1.funColor);//yellow
        }
    }
    //测试类2
    public class Test {
        public static void main(String args[]) {
            Test test = new Test();
            Animal a = new Animal("name");
            Cat c = new Cat("catname", "blue");
            Dog d = new Dog("dogname", "black");
            test.f(a);
            test.f(c);
            test.f(d);
        }
        //定义一个方法
        public void f(Animal a) {
            System.out.println("name: "+a.name);
            if(a instanceof Cat) {
                Cat cat = (Cat)a;
                System.out.println(" "+cat.eyesColor+" eyes");
            }else if(a instanceof Dog) {
                Dog dog = (Dog)a;
                System.out.println(" "+dog.funColor+" fur");
            }
        }
    }
    
    /*输出结果
    name: name
    name: catname
     blue eyes
    name: dogname
     black fur
     */

    十七、动态绑定(多态)

    动态绑定是指“在执行期间(而非编译其间)判断所引用对象的实际类型,根据其实际的类型调用其相应的方法”

    看一个例子

    //新建一个基类
    public class Animal {
        public String name;
        Animal(String name) {
            this.name = name;
        }
        public void enjoy() {
            System.out.println("叫声....");
        }
    }
    //新建一个子类Cat继承Animal基类
    public class Cat extends Animal {
        public String eyesColor;
        Cat(String n, String c) {
            super(n);
            eyesColor = c;
        }
        public void enjoy() {
            System.out.println("猫叫声...");
        }
    }
    //新建一个子类Dog继承基类Animal
    public class Dog extends Animal{
        public String funColor;
        Dog(String n,String c) {
            super(n);
            funColor = c;
        }
        public void enjoy() {
            System.out.println("狗叫声...");
        }
    }
    //Lady类
    public class Lady {
        private String name;
        private Animal pet;
        Lady(String name,Animal pet) {
            this.name = name;
            this.pet = pet;
        }
        public void myPetEnjoy() {
            pet.enjoy();
        }
    }
    //测试类
    public class Test {
        public static void main(String args[]) {
            Cat c = new Cat("catname","blue");
            Dog d = new Dog("dogname", "black");
            Lady l1 = new Lady("l1",c);
            Lady l2 = new Lady("l2", d);
            l1.myPetEnjoy();
            l2.myPetEnjoy();
        }
    }

    输出结果为:

    猫叫声...
    狗叫声...

    上面的例子中,根据lady对象的成员变量pet所引用的不同的实际类型而调用相应的enjoy方法

    Cat c = new Cat("catname","blue");
    Dog d = new Dog("dogname", "black");
    Lady l1 = new Lady("l1",c);

    上面三行代码的内存分配图如下:

    image

    enjoy方法有三个,分别是animal的,dog的和cat的,动态绑定就是调用的实际new的那个方法,指向的就是那个方法。也就是l1指向的实际方法应该是cat的那个enjoy方法。

    当后期需要扩展的时候,只需要加一个扩展类,然后在test类中new一个扩展对象出来并使用对象.方法的方式引用即可,扩展性非常强

    多态的存在有三个必要条件:

    1)要有继承

    2)要有重写

    3)父类引用指向子类对象

    十八、抽象类(abstract)

    使用abstract关键字来修饰一个类的时候,这个类叫做抽象类;同样的,使用abstract来修饰一个方法时,这个方法叫做抽象方法。

    含有抽象方法的类必需被声明为抽象类,抽象类必需被继承,抽象方法必需被重写。

    抽象类不能被实例化

    抽象方法只需声明,而不需要实现

    //修改基类
    abstract class Animal {
        public String name;
        Animal(String name) {
            this.name = name;
        }
        /*
        public void enjoy() {
            System.out.println("叫声....");
        }
        */
        public abstract void enjoy();
    }

    由于在之前的那个例子中,基类的方法是没有被实现的,这个时候就可以使用abstract关键字将基类的方法和类变为抽象方法、抽象类,只是被继承,强制子类必需重写方法

    十九、final关键字

    final修饰的变量的值不能够被改变

    final修饰的方法不能够被重写

    final修饰的类不能够被继承

    //示例代码
    public class TestFinal {
        public static void main(String[] args) {
            T t = new T();
            t.i = 9;
        }
        
    }
    class T {
        final int i = 0;
    }

    如上的代码中会报错,因为在T类中已经定义了final int i的值,所以在new出来的新的t中是无法对i的值进行修改的,即便把t.i改为0也会报错。因为在执行过程中是将0重新赋值给了t.i

    二十、接口

    接口(interface)是抽象方法和常量值的定义的集合

    本质上讲,接口是一种特殊的抽象类,这种抽象类中值包含常量和方法的定义,而没有变量和方法的实现

    接口定义举例:

    public interface Runner {
        public static final int id = 1;
        public void start();
        public void run();
        public void stop();
    }

    接口特性:

    • 接口可以多重实现
    • 接口中声明的属性默认为public static final的;也只能是public static final的
    • 接口只能定义抽象方法,而且这些方法默认为public的,也只能是public的
    • 接口可以继承其他的接口,并添加新的属性和抽象方法
    • 多个无关的类可以实现同一个接口
    • 一个类可以实现多个无关的接口
    • 与继承关系类似,接口与实现类之间存在多态性

    定义java类的语法格式:

    < modifier > class < name > [ extends < superclass > ] [ implements < interface > [ , <interface> ] * ] {
         < declarations > * 
    }

    看个例子:

    //定义一个接口类Singer
    interface Singer {
        public void sing();
        public void sleep();
    }
    
    //再定义一个接口类
    interface Painter {
        public void paint();
        public void eat();
    }
    
    //定义students类实现singer接口
    public class Students implements Singer {
        private String name;
        Students(String name) {
            this.name = name;
        }
        public void study() {
            System.out.println("studying...");
        }
        public String getName() {
            return name;
        }
        public void sing() {
            System.out.println("student is singing...");
        }
        public void sleep() {
            System.out.println("student is sleeping..");
        }
    }
    
    //定义类实现singer和painter类
    class Teacher implements Singer,Painter{
        private String name;
        public String getString() {
            return name;
        }
        Teacher(String name) {
            this.name = name;
        }
        public void teach() {
            System.out.println("teaching");
        }
        public void sing(){
            System.out.println("teacher is singing");
        }
        public void sleep() {
            System.out.println("teacher is sleeping");
        }
        public void paint() {
            System.out.println("teacher is painting");
        }
        public void eat() {
            System.out.println("teacher is eating");
        }
    }
    //调试输出的测试类
    public class test {
            public static void main(String args[]) {
                Singer s1 = new Students("s1");
                s1.sing();
                s1.sleep();
                Singer s2 = new Teacher("s2");
                s2.sing();
                s2.sleep();
                Painter p1 = (Painter)s2;
                p1.paint();
                p1.eat();
            }
    }

    输出结果:

    student is singing...
    student is sleeping..
    teacher is singing
    teacher is sleeping
    teacher is painting
    teacher is eating
  • 相关阅读:
    Spring Boot 2 快速教程:WebFlux Restful CRUD 实践(三)
    Spring Boot 2 快速教程:WebFlux 快速入门(二)
    ES 集群上,业务单点如何优化升级?
    Spring Boot 2.x 系列教程:WebFlux 系列教程大纲(一)
    泥瓦匠想做一个与众不同的技术"匠"
    java编程行业微信群,无论新手老手欢迎加入,会一直更新
    Spring Boot 2.x 系列教程:WebFlux REST API 全局异常处理 Error Handling
    解决方案:如何防止数据重复插入?
    阿里 Java 手册系列教程:为啥强制子类、父类变量名不同?
    品阿里 Java 开发手册有感
  • 原文地址:https://www.cnblogs.com/JianXu/p/5575663.html
Copyright © 2020-2023  润新知