java实现多态有几种方式？分别是啥?

Posted 2023-04-30

首先，多态存在的三个必要条件
一、要有继承；
二、要有重写；
三、父类引用指向子类对象。
多态引用类型有两种方式：
a. 编译时多态：方法的重载；
b. 运行时多态：JAVA运行时系统根据调用该方法的实例的类型来决定选择调用哪个方法则被称为运行时多态。（我们平时说得多的事运行时多态，所以多态主要也是指运行时多态）； 参考技术A 基本上是重载、接口、继承 可通过这三种方式实现 多态 参考技术B 多态的实现方式：

1、重写
2、接口
3、抽象类和抽象方法 参考技术C 三种：方法的重载，继承或实现接口，父类引用指向子类对象 参考技术D 条件：要有继承，要有重写，要有父类引用指向子类对象。有四种。强制的：隐式做类型转换，如1.0+1.0、1.0+1、1.0+"1"等重载的：相同的运算符或方法，去表示截然不同的意义。+在上面有多个意思：两个double型的数相加、两个串相连、整型相加，长整型等等。参数的：为不同类型的参数提供相同的操作。例如抽象类中，描述了一组具有同样特征的对象，提供一个通用模板。通过指定一种类型以重用抽象类。这些参数可以是用户定义的很多类型，参数多态是最强大的多态。包含的：类包含关系的抽象操作。如通过值的类型和集合的包含关系实现了多态的行为。

java多线程有几种实现方法,都是什么?

 转自：http://www.cnblogs.com/liujichang/p/3150387.html

多线程有两种实现方法，分别是继承Thread类与实现Runnable接口

同步的实现方法有两种，分别是synchronized,wait与notify

先看一下java线程运行时各个阶段的运行状态

java实现多线程有两种方法

1、继承Thread类

2、实现Runnable接口

这两种方法的共同点：

不论用哪种方法，都必须用Thread（如果是Thead子类就用它本身）产生线程，然后再调用start()方法。

两种方法的不同点：

1、继承Thread类有一个缺点就是单继承，而实现Runnable接口则弥补了它的缺点，可以实现多继承

2、继承Thread类必须如果产生Runnable实例对象，就必须产生多个Runnable实例对象，然后再用Thread产生多个线程；而实现Runnable接口，只需要建立一个实现这个类的实例，然后用这一个实例对象产生多个线程。即实现了资源的共享性

基于以上两点所以建议用第二种方法

 1 package cn.itcast.demo1;
 2 
 3 public class MyThread extends Thread {
 4     private String name;
 5     public MyThread(String name){
 6         this.name = name;
 7     }
 8     //如果要使用多线程，则必须有一个方法的主体
 9     public void run(){
10         //打印输出
11         for(int i = 0;i < 10; i++){
12             System.out.println(this.name + "----->运行");
13         }
14     }
15 
16 }

 1 package cn.itcast.demo1;
 2 
 3 public class Demo5 {
 4     public static void main(String[] args) {
 5         Runnable r1 = new MyThread("线程一");
 6         Runnable r2 = new MyThread("线程二");
 7         Runnable r3 = new MyThread("线程三");
 8         
 9         Thread t1 = new Thread(r1);
10         Thread t2 = new Thread(r2);
11         Thread t3 = new Thread(r3);
12         
13         t1.start();
14         t2.start();
15         t3.start();
16         
17     }
18     
19 
20 }

 1 package cn.itcast.demo1;
 2 
 3 public class Demo6 {
 4 
 5     public static void main(String[] args) {
 6         // TODO Auto-generated method stub
 7         MyThread mt1 = new MyThread("线程A");
 8         MyThread mt2 = new MyThread("线程B");
 9         MyThread mt3 = new MyThread("线程C");
10         
11         mt1.start();
12         mt2.start();
13         mt3.start();
14 
15     }
16 
17 }

这是继承了Thread类，第一种方法产生多个Runnable实例对象，然后用Thread产生多个线程

第二种方法，因为这个类已经继承了Thread类，所以就可以直接利用它本身产生多个线程

程序2：

 1 package cn.itcast.demo1;
 2 
 3 public class MyThread1 implements Runnable {
 4     private int ticket = 10;
 5 
 6     @Override
 7     public void run() {
 8         // TODO Auto-generated method stub
 9         for(int i = 0; i < 500;i++){
10             if(this.ticket > 0){
11                 System.out.println("卖票------》" + (this.ticket--));
12             }
13         }
14 
15     }
16 
17 }

 1 package cn.itcast.demo1;
 2 
 3 public class Demo7 {
 4 
 5     public static void main(String[] args) {
 6         // TODO Auto-generated method stub
 7         MyThread1 mt = new MyThread1();
 8         Thread t1 = new Thread(mt);
 9         Thread t2 = new Thread(mt);
10         Thread t3 = new Thread(mt);
11         
12         t1.start();
13         t2.start();
14         t3.start();
15         
16 
17     }
18 
19 }

这个程序是实现Runnable了，产生一类的实例对象，然后用Thread产生多个线程。