9.java中实现多态的机制是什么？java 中实现多态的机制是什么
本篇文章给大家谈谈9.java中实现多态的机制是什么，以及java 中实现多态的机制是什么对应的知识点，文章可能有点长，但是希望大家可以阅读完，增长自己的知识，最重要的是希望对各位有所帮助，可以解决了您的问题，不要忘了收藏本站喔。
JAVA中文是什么意思
JAVA中文意思是:计算机编程语言。
Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。
任职于太阳微系统的詹姆斯·高斯林等人于1990年代初开发Java语言的雏形，最初被命名为Oak，目标设置在家用电器等小型系统的编程语言，应用在电视机、电话、闹钟、烤面包机等家用电器的控制和通信。
由于这些智能化家电的市场需求没有预期的高，Sun公司放弃了该项计划。随着1990年代互联网的发展，Sun公司看见Oak在互联网上应用的前景，于是改造了Oak，于1995年5月以Java的名称正式发布。Java伴随着互联网的迅猛发展而发展，逐渐成为重要的网络编程语言。
扩展资料：
JAVA和互联网的渊源：
1994年6月，在同约翰·盖吉、詹姆斯·高斯林、比尔·乔伊、帕特里克·诺顿、韦恩·罗斯因和埃里克·施密特经历了一场历时三天的头脑风暴后，团队决定再一次改变努力的目标，这次他们决定将该技术应用于万维网。
他们认为随着Mosaic浏览器的到来，因特网正在向同样的高度互动的远景演变，而这一远景正是他们在有线电视网中看到的。作为原型，帕特里克·诺顿写了一个小型万维网浏览器，WebRunner，后来改名为HotJava[12]。
1994年10月，HotJava和Java平台为公司高层进行演示。1994年，Java 1.0a版本已经可以提供下载，但是Java和HotJava浏览器的第一次公开发布却是在1995年3月23日SunWorld大会上进行的。升阳公司的科学指导约翰·盖吉宣告Java技术。
这个发布是与网景公司的执行副总裁马克·安德森的惊人发布一起进行的，宣布网景将在其浏览器中包含对Java的支持。1996年1月，Sun公司成立了Java业务集团，专门开发Java技术。
参考资料来源：百度百科-Java
java 中实现多态的机制是什么
多态就是指一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。
因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。
扩展资料：
特点：
指向子类的父类引用由于向上转型了，它只能访问父类中拥有的方法和属性，而对于子类中存在而父类中不存在的方法，该引用是不能使用的，尽管是重载该方法。
若子类重写了父类中的某些方法，在调用该些方法的时候，必定是使用子类中定义的这些方法（动态连接、动态调用）。
参考资料来源：百度百科-多态
在Java 中多线程的实现方法有哪些,如何使用
Java多线程的创建及启动
Java中线程的创建常见有如三种基本形式
1.继承Thread类，重写该类的run()方法。
复制代码
1 class MyThread extends Thread{
2
3 private int i= 0;
4
5@Override
6 public void run(){
7 for(i= 0; i< 100; i++){
8 System.out.println(Thread.currentThread().getName()+""+ i);
9}
10}
11}
复制代码
复制代码
1 public class ThreadTest{
2
3 public static void main(String[] args){
4 for(int i= 0; i< 100; i++){
5 System.out.println(Thread.currentThread().getName()+""+ i);
6 if(i== 30){
7 Thread myThread1= new MyThread();//创建一个新的线程 myThread1此线程进入新建状态
8 Thread myThread2= new MyThread();//创建一个新的线程 myThread2此线程进入新建状态
9 myThread1.start();//调用start()方法使得线程进入就绪状态
10 myThread2.start();//调用start()方法使得线程进入就绪状态
11}
12}
13}
14}
复制代码
如上所示，继承Thread类，通过重写run()方法定义了一个新的线程类MyThread，其中run()方法的方法体代表了线程需要完成的任务，称之为线程执行体。当创建此线程类对象时一个新的线程得以创建，并进入到线程新建状态。通过调用线程对象引用的start()方法，使得该线程进入到就绪状态，此时此线程并不一定会马上得以执行，这取决于CPU调度时机。
2.实现Runnable接口，并重写该接口的run()方法，该run()方法同样是线程执行体，创建Runnable实现类的实例，并以此实例作为Thread类的target来创建Thread对象，该Thread对象才是真正的线程对象。
复制代码
1 class MyRunnable implements Runnable{
2 private int i= 0;
3
4@Override
5 public void run(){
6 for(i= 0; i< 100; i++){
7 System.out.println(Thread.currentThread().getName()+""+ i);
8}
9}
10}
复制代码
复制代码
1 public class ThreadTest{
2
3 public static void main(String[] args){
4 for(int i= 0; i< 100; i++){
5 System.out.println(Thread.currentThread().getName()+""+ i);
6 if(i== 30){
7 Runnable myRunnable= new MyRunnable();//创建一个Runnable实现类的对象
8 Thread thread1= new Thread(myRunnable);//将myRunnable作为Thread target创建新的线程
9 Thread thread2= new Thread(myRunnable);
10 thread1.start();//调用start()方法使得线程进入就绪状态
11 thread2.start();
12}
13}
14}
15}
复制代码
相信以上两种创建新线程的方式大家都很熟悉了，那么Thread和Runnable之间到底是什么关系呢？我们首先来看一下下面这个例子。
复制代码
1 public class ThreadTest{
2
3 public static void main(String[] args){
4 for(int i= 0; i< 100; i++){
5 System.out.println(Thread.currentThread().getName()+""+ i);
6 if(i== 30){
7 Runnable myRunnable= new MyRunnable();
8 Thread thread= new MyThread(myRunnable);
9 thread.start();
10}
11}
12}
13}
14
15 class MyRunnable implements Runnable{
16 private int i= 0;
17
18@Override
19 public void run(){
20 System.out.println("in MyRunnable run");
21 for(i= 0; i< 100; i++){
22 System.out.println(Thread.currentThread().getName()+""+ i);
23}
24}
25}
26
27 class MyThread extends Thread{
28
29 private int i= 0;
30
31 public MyThread(Runnable runnable){
32 super(runnable);
33}
34
35@Override
36 public void run(){
37 System.out.println("in MyThread run");
38 for(i= 0; i< 100; i++){
39 System.out.println(Thread.currentThread().getName()+""+ i);
40}
41}
42}
复制代码
同样的，与实现Runnable接口创建线程方式相似，不同的地方在于
1 Thread thread= new MyThread(myRunnable);
那么这种方式可以顺利创建出一个新的线程么？答案是肯定的。至于此时的线程执行体到底是MyRunnable接口中的run()方法还是MyThread类中的run()方法呢？通过输出我们知道线程执行体是MyThread类中的run()方法。其实原因很简单，因为Thread类本身也是实现了Runnable接口，而run()方法最先是在Runnable接口中定义的方法。
1 public interface Runnable{
2
3 public abstract void run();
4
5}
我们看一下Thread类中对Runnable接口中run()方法的实现：
复制代码
@Override
public void run(){
if(target!= null){
target.run();
}
}
复制代码
也就是说，当执行到Thread类中的run()方法时，会首先判断target是否存在，存在则执行target中的run()方法，也就是实现了Runnable接口并重写了run()方法的类中的run()方法。但是上述给到的列子中，由于多态的存在，根本就没有执行到Thread类中的run()方法，而是直接先执行了运行时类型即MyThread类中的run()方法。
3.使用Callable和Future接口创建线程。具体是创建Callable接口的实现类，并实现clall()方法。并使用FutureTask类来包装Callable实现类的对象，且以此FutureTask对象作为Thread对象的target来创建线程。
看着好像有点复杂，直接来看一个例子就清晰了。
复制代码
1 public class ThreadTest{
2
3 public static void main(String[] args){
4
5 Callable<Integer> myCallable= new MyCallable();//创建MyCallable对象
6 FutureTask<Integer> ft= new FutureTask<Integer>(myCallable);//使用FutureTask来包装MyCallable对象
7
8 for(int i= 0; i< 100; i++){
9 System.out.println(Thread.currentThread().getName()+""+ i);
10 if(i== 30){
11 Thread thread= new Thread(ft);//FutureTask对象作为Thread对象的target创建新的线程
12 thread.start();//线程进入到就绪状态
13}
14}
15
16 System.out.println("主线程for循环执行完毕..");
17
18 try{
19 int sum= ft.get();//取得新创建的新线程中的call()方法返回的结果
20 System.out.println("sum="+ sum);
21} catch(InterruptedException e){
22 e.printStackTrace();
23} catch(ExecutionException e){
24 e.printStackTrace();
25}
26
27}
28}
29
30
31 class MyCallable implements Callable<Integer>{
32 private int i= 0;
33
34//与run()方法不同的是，call()方法具有返回值
35@Override
36 public Integer call(){
37 int sum= 0;
38 for(; i< 100; i++){
39 System.out.println(Thread.currentThread().getName()+""+ i);
40 sum+= i;
41}
42 return sum;
43}
44
45}
复制代码
首先，我们发现，在实现Callable接口中，此时不再是run()方法了，而是call()方法，此call()方法作为线程执行体，同时还具有返回值！在创建新的线程时，是通过FutureTask来包装MyCallable对象，同时作为了Thread对象的target。那么看下FutureTask类的定义：
1 public class FutureTask<V> implements RunnableFuture<V>{
2
3//....
4
5}
1 public interface RunnableFuture<V> extends Runnable, Future<V>{
2
3 void run();
4
5}
于是，我们发现FutureTask类实际上是同时实现了Runnable和Future接口，由此才使得其具有Future和Runnable双重特性。通过Runnable特性，可以作为Thread对象的target，而Future特性，使得其可以取得新创建线程中的call()方法的返回值。
执行下此程序，我们发现sum= 4950永远都是最后输出的。而“主线程for循环执行完毕..”则很可能是在子线程循环中间输出。由CPU的线程调度机制，我们知道，“主线程for循环执行完毕..”的输出时机是没有任何问题的，那么为什么sum=4950会永远最后输出呢？
原因在于通过ft.get()方法获取子线程call()方法的返回值时，当子线程此方法还未执行完毕，ft.get()方法会一直阻塞，直到call()方法执行完毕才能取到返回值。
上述主要讲解了三种常见的线程创建方式，对于线程的启动而言，都是调用线程对象的start()方法，需要特别注意的是：不能对同一线程对象两次调用start()方法。
你好，本题已解答,如果满意
请点右下角“采纳答案”。
文章到此结束，如果本次分享的9.java中实现多态的机制是什么和java 中实现多态的机制是什么的问题解决了您的问题，那么我们由衷的感到高兴！