正文

java多态注意项小结

︶ㄣ米米素材网 メ
米米素材网V管理员 / 阅读
0710

面向对象的三大特性：封装、继承、多态。从一定角度来看，封装和继承几乎都是为多态而准备的。今天通过本文给大家介绍java多态注意项总结，感兴趣的朋友一起看看吧

展示多态现象

?
1
2
3
4
5
6
7
package test;
 
//父类引用，指向(不同子类)的实例，对同一个实例方法名调用，调用的程序不
//一样。继承是多态得以实现的基础。
public interface test1 {
    void shout();
}
?
1
2
3
4
5
6
7
package test;
 
public class test2 implements test1 {
    public void shout() {
        System.out.println("1111");
    }
}
?
1
2
3
4
5
6
7
package test;
 
public class test3 implements test1 {
    public void shout() {
        System.out.println("222222");
    }
}
?
1
2
3
4
5
6
7
8
9
10
11
12
package test;
 
public class test4 {
    public static void main(String[] args) {
        test1 ts = new test2();
        ts.shout();
 
        test1 ts1 = new test3();
        ts1.shout();
    }
 
}

多态的基础以及限制

?
1
2
3
4
5
6
7
8
9
package test;
 
public class test5 {
    public static void speak() {
 
        System.out.println("speak:");
    }
 
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package test;
 
public class test6 extends test5{
 
    public static void speak() {
        System.out.println("11111");
    }
//多态的基础是继承和重写
    //多态仅限于实例方法
    public static void main(String[] args) {
        test5 ts1 = new test5();
        test6 ts = new test6();
        ts1.speak();
        ts.speak();
    }
}

对象类型转换

?
1
2
3
4
5
6
7
package test;
 
public class test7 {
        public void speak(){
            System.out.println("speak:");
        }
}
?
1
2
3
4
5
6
7
8
package test;
 
public class test8 extends test7{
    @Override
    public void speak() {
        System.out.println("1111");
    }
}
?
1
2
3
4
5
6
7
8
9
10
11
12
package test;
 
public class test9 extends test7 {
    @Override
    public void speak() {
        System.out.println("22222");
    }
 
    protected void action() {
        System.out.println("敲代码");
    }
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package test;
 
public class test10 {
    public static void main(String[] args) {
        //向上类型转换 隐式 安全
        //将test8的对象当作test7类型来用
        test7 ts = new test8();
        ts.speak();
 
        //强制类型转换 显示 不安全
 
        test7 ts1 = new test9();
        test9 ts2 = (test9) ts1;
        ts2.speak();
 
        //怎么避免强制类型转换带来的不安全  面向接口编程加instanceof
 
        test7 ts3 = new test8();
        test7 ts4 = null;
        if (ts3 instanceof test9) {
            ts4 = (test9) ts3;
        }
        if (ts3 instanceof test8) {
            ts4 = (test8) ts3;
        }
        ts4.speak();
    }
 
}

object类

java多态注意项小结

Object类的常用方法也可以被重写

?
1
2
3
4
5
6
7
8
package test;
 
public class test11 {
 
    public void speak(){
        System.out.println("speak:");
    }
}
?
1
2
3
4
5
6
7
8
9
10
11
12
package test;
 
public class test12 {
    public static void main(String[] args) {
        test11 ts = new test11();
        ts.speak();
        //返回该对象的字符串表示
        System.out.println(ts.toString());
        //返回该对象的哈希码值
        System.out.println(ts.hashCode());
    }
}

匿名内部类

?
1
2
3
4
5
package test;
 
public interface test13 {
    void speak();
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package test;
 
public class test14 {
 
    //类里面定义的类称之为内部类（Inner Class），内部类是外部类的一个成员。
    //Java内部类可以分为：成员内部类、方法内部类和匿名内部类等。
    class person implements test13{
 
        @Override
        public void speak() {
            System.out.println("111111");
        }
    }
 
    public static void main(String[] args) {
        class person1 implements test13{
            @Override
            public void speak() {
                System.out.println("2222222222");
            }
        }
 
//        可以使用匿名内部类来实现接口。所谓匿名内部类就是没有名字的内部类，表面上看
//        起来它似乎有名字，实际那不是它的名字。当程序中使用匿名内部类时，在定义匿名
//        内部类的地方往往直接创建该类的一个对象。
        new test13(){
            @Override
            public void speak() {
                System.out.println("3333333");
            }
        }.speak();
    }
}

到此这篇关于java多态注意项总结的文章就介绍到这了,更多相关java多态内容请搜索米米素材网以前的文章或继续浏览下面的相关文章希望大家以后多多支持米米素材网！

原文链接：https://blog.csdn.net/weixin_44692890/article/details/120782329