说说你的理解----面向对象的本质是什么?封装，继承，多态是到底用来做什么的?

[JCC0128]

说说你的理解----面向对象的本质是什么?封装，继承，多态是到底用来做什么的?

本人没专门看过面向对象的书，理解很浅，如下，请各位老大说说自己的理解，或推荐一下看什么书(或相关网页)，谢谢!


代码的要求：可维护，可扩展，可重用

1.对象:为模拟现实世界，将万物都看为对象，即现实世界具体的事物
2.类：对 对象 的抽象,实现了一次代码重用，类的所有对象都可以使用这些代码
3.封装：完成了 接口与实现的分离，提高可维护性
4.继承：代码重用
5.多态：由继承而延申，主要目的是为了模拟现实的需要(即不同子类有不同的具体的实现方法)，一定程度提高了代码重用(不同子类可公用同一段代码)，但think in java 3中关于多态有一段话不理解，"多态性是站在类的角度完成了接口与实现的分离",什么意思?

[zengpan_panpan]

这里详细说明一下第一种：
myrunner是个可运行的对象，就是实现了Runnable的接口的对象。

而第一的思路就是。先向池子要一个线程，然后用这个线程去运行这个myrunner，用完以后再把线程还给池子。

[cwwwj]

面向对象的本质是: 抽象

[Minsc79]

这才像个论坛，大家说的很好啊，值得收藏，继续关注！

[hjwl]

再顶一下！！

[zengpan_panpan]

看来现在提线程池，还为时过早。

http://expert.csdn.net/Expert/topic/2631/2631505.xml?temp=.8645441
这篇文章，后面大致提了一下线程池的实现。

http://java.sun.com/docs/books/tutorial/essential/threads/synchronization.html
一直到
http://java.sun.com/docs/books/tutorial/essential/threads/waitAndNotify.html
提供了生产者消费者问题的java实现，是实现线程池的核心问题。

[neary]

个人意见：面向对象只可意会，不可言传。说不清楚的，何况每个人的理解方向不同，只能一点一点去意会。

[guoxyj]

我也帮忙顶

[xueqs]

学习

[iamwls]

我试着答线程池的问题
两种客户端方案其实是一样的

这样写就可以同时提供两种方案的支持
个人觉得线程池的问题和面向对象的本质好象没多大关系

class TPool
{
public static void start(Runner myrunner){
Thread t = TPool.getInstance().get();
t.start(myrunner);
TPool.getInstance().put(t);
}
}

[zengpan_panpan]

其实第一种方法不好。
虽然符合一般池子的概念，比如，向池子申请资源，归还资源。

但是就因为这样将造成线程使用者和线程池之间的强耦合。

比如向线程池请求一个线程，就不得不考虑，它还有没有线程可以提供给我用？如果没有到底是返回错误，还是还是把我挂起？另外线程运行了我的runner，我什么时候知道知道它结束，如果它还没有结束，我又怎么能把线程归还给池子。考虑这些问题自然就很麻烦了，不但设计应用麻烦，设计线程池也麻烦。

而第二种就很简单了。
把我的runner直接提供给池子，如果它暂时没有线程可用，那么排队就是了。如果不允许排队可以考虑增加一个addTask，提供个参数说明我不排队，要是没有直接报错。更多的通过这个参数甚至可以控制线程优先级一系列的问题，而不需要对池子有多大改动。

线程池本身，涉及到很多方面的问题，比如操作系统调度之类的问题，里面也会包含一些对象化的思考，这些思考并不在于用什么具体语言去实现。现在给出第二种的最简单实现，可以去分析一下里面到底有多少对象化概念，有什么模式，也可能像这种模式，不过似是而非，但是这些都不重要，并不见得一定要符合什么模式才是对的。前面已经说过，不管面向什么，不管什么方法，最终都是面向需求的。最后应该把你的程序看成一块胶泥，想捏成圆的就圆的，想捏成方的就方的。

// TPool.java
import java.lang.*;
import java.util.*;
import java.io.*;

class MyRunner implements Runnable
{
String name;

public MyRunner(String x)
{
name = x;
}

public void run()
{
System.out.println("My name is " + name);
try { Thread.sleep(50); } catch (Exception e) {}

}
}

public class TPool implements Runnable
{
private int id;
private static LinkedList pool = new LinkedList();
private TPool (int i) { id = i; }

public void run()
{
for (;;)
{
Runnable r;
synchronized(pool)
{
System.out.println("[Thread " + id + "] Enter Sleep");
while (pool.size() == 0)
{
try
{
pool.wait();
} catch(InterruptedException e)
{
}
}
r = (Runnable)pool.getFirst();
pool.removeFirst();
System.out.println("[Thread " + id + "] Exec Runner");
}
r.run();
}
}

static void addTask(Runnable r)
{
synchronized(pool)
{
pool.add(r);
pool.notifyAll();
}
}

static void init (int size)
{
for (int i = 0; i < size; i++)
(new Thread(new TPool(i))).start();
}

static void main(String args[])
{
TPool.addTask(new MyRunner("A"));
TPool.addTask(new MyRunner("B"));
TPool.addTask(new MyRunner("C"));
TPool.init(3);
for(;;)
try
{
Thread.sleep(1000);
int n = (int)(Math.random() * 5);
System.out.println("\nGenerate " + n + " Tasks\n");
for (int i = 0; i < n; i++)
TPool.addTask(new MyRunner( (new Double(Math.random())).toString() ));
} catch(Exception e)
{
}
}
}

[mymoto]

多态是最神奇的，就想你说的，多态性是站在类的角度完成了接口与实现的分离，定义大家公用的接口，每个人虽然都不知道是如何实现接口的，但是你只要知道这个接口，你就可以使用，神奇吧，就好比说电视的天线接口都是一个规格，你不用管每个电视内部是如何实现对这个接口的支持的，可能会有千百种方法，但没关系，你随便买条有线的线插上就好用了，这就是隐藏实现细节

[blue999star]

mark

[javaprogramlover]

我比较赞同土豆仙的理解！

[dropship]

慢慢看

[老土豆T]

javaprogramlover
-_-!!!

很遗憾的告诉你，我的理解是不正确的。

[javaCandelaboy]

真是太精彩了，收藏！！！

[zmpcoming]

mark

[hnsoso]

我还说不上什么,初学,好贴,慢慢看,慢慢理解,大家的看法

[lqtflwg718]

还不结贴，占用资源！

[tomuno]

说说你的理解----面向对象的本质是什么?封装，继承，多态是到底用来做什么的?

java并不是100%的面向对象语言，所以说有些东西非要用对象来解释就解释不清楚
而Sun公司不断更新的JDK会在表面上不断进行修改，为的是让你感觉不到静态事物的存在

封装：
封装就是将客户端不应看到的信息包裹起来。使内部执行对外部来看不一种不透明的、是一个黑箱，客户端不需要内部资源就能达到他的目的。下面让我们从不同角度对封装加以分析。

以最终客户的角度来看，.jar文件就是一种封装，他们不需要知道.jar文件中有多少个.class文件，每个文件中的功能与作用，同样可以得到他们希望的结果。

访问控制符为隐藏实施细节提供了一种方式，使代码级的对类、方法、属性的封装成为可能。用包控制符和访问控制符只是封装的手段，由此方式可以抽象出四种形式。那就是类的封装、对象的封装、方法的封装和属性的封装

继承：可以通过不断的继承来实现更复杂的功能。
多态：处理多种状态，使方法更加强壮。目的：我们用这个方法的时候最好不用去考虑参数的类别，只要是合理的参数 任何类型的都可以加进去。