JAVA - 抽象
JAVA - Abstraction
我对 java 中的抽象有点困惑。
我查了很多页面说抽象就是数据隐藏(隐藏实现)。
我对抽象的理解是'partial implementation'。只需在摘要 class/interface 中定义您需要的内容,然后 extend/implement 然后添加您自己的功能。
我不明白这是怎么隐藏数据的?实施 class/interface 后,您将可以访问代码,并根据需要对其进行修改。
我查了很多问题,关于这方面的文章,但仍然对此感到困惑。
感谢任何帮助。
谢谢
数据隐藏是指您在不阅读文档的情况下无法理解API内部如何工作(例如,ArrayList
)。 API 创建者不提供任何访问底层数组的权限。
您向将要使用它的用户隐藏 API 实现。他们不应该担心它在内部是如何工作的,他们只对提供给他们的功能感兴趣。
关于那个 a good article。
您将 abstraction(编程模式)与 Java 语言的 abstract 关键字混淆了。尽管相似,但它们在语义上的相关性很小。
抽象 意味着您从使用 class 或方法的代码中隐藏实现细节。使用您的方法的代码不需要知道您正在实现一个列表,使用数组或动态指针或嵌入式数据库或文件系统中的文件。
abstract 用于标记 class 具有仅声明但未实现的方法。它是 "abstract",因为它们不能被实例化,你不能从这些 classes 中创建任何实例(但你可以从它们的具体子 classes 中创建它们)。
它不是对你隐藏信息,而是对你抽象的客户端。看看这个例子。
public class Demo {
Client client = new Client(new Implementation());
}
public interface Abtraction {
void doWork();
}
public class Implementation implements Abtraction{
@Override
public void doWork() {
//doingTheWork
}
}
public class Client{
private Abtraction theAbstraction;
public Client(Abstraction theAbstraction){
this.theAbstraction = theAbstraction;
}
}
class Client
不知道 Abstraction
的实现,这意味着 Demo
class 可以提供 [=12] 的不同实现=] 而不会弄乱 Client
.
数据隐藏 基本上是隐藏有关 class 的内部数据成员的详细信息,并且仅 排他性地 提供有关 class 访问它。
从而避免了来自应用程序中的其他classes或来自任何其他应用程序的不必要的渗透,这意味着其他classes无法直接访问私有成员变量。
因此,您可以通过这种方式抽象有关class的内部细节。
我不确定这是否回答了你的问题,但如果你谈论的是一般的抽象 classes,它们在那里为 child class 提供功能扩展它而 child class 不必知道或处理实现的所有细节(它对 child class 的用户隐藏)。
我们以汽车为例:
public abstract class Vehicle {
protected int _numberOfWheels;
public Vehicle() {
this._numberOfWheels = 4;
}
}
public class Truck extends Vehicle {
public int carryingLoad;
public Truck() {
this.carryingLoad = 4000; // kg or something
}
}
所以 vehicle 是车辆的一个抽象实例 object 并且已经具有一些与之关联的功能,例如车轮的数量。这是一个受保护的方法,所以如果我创建一个新的卡车实例:
// Inside main
Truck truck = new Truck();
我无法更改轮子的数量,但是,如果我要在 class 中为卡车编写函数,例如:
// Inside the Truck class
public void addSpareTire() {
this._numberOfWheels++;
}
这样我就可以这样称呼它:
// Inside main
truck.addSpareTire();
我仍然可以与一些变量进行交互,但只能遍历扩展抽象 class 的 class 中的函数。我可以通过调用 addSpareTire()
一次添加一个轮胎,但我永远无法从我正在 使用 [=16] 的主函数直接与 _numberOfWheels
交互=]object,但我可以从Truck
class声明里面。来自卡车object的用户,该信息是隐藏。
我不知道这是不是你要的。希望这有帮助。
在面向对象编程中抽象是对用户隐藏实现细节的过程,只有功能会提供给用户。换句话说,用户将获得有关对象做什么的信息,而不是它如何做的信息。
查看以下内容 link 了解更多详情:
http://www.visionsdeveloper.com/tutorial/java/java-abstraction.jsp
也许一个例子能更好地帮助你。假设你想实现一个图 class,它可能有邻接表或邻接矩阵来表示它的节点。所以抽象地说,你至少要 "addNode" "addEdge" 这个图:
public abstract class Graph
{
public abstract int addNode();
public abstract void addEdge(int from, int to);
}
现在您可以扩展两个 classes:
public class GraphAdjList extends Graph
{
private Map<Integer,ArrayList<Integer>> adjListsMap;
public int addNode()
{
//list based implementation
}
public void addEdge(int from, int to)
{
//list based implementation
}
}
public class GraphAdjMatrix extends Graph
{
private int[][] adjMatrix;
public int addNode()
{
//matrix based implementation
}
public void addEdge(int from, int to)
{
//matrix based implementation
}
}
当你从这两个 classes 调用 addEdge 中的任何一个时,你不必担心它背后的数据结构,你只知道你得到了你需要的结果,例如:
Graph g1,g2;
g1 = new GraphAdjList();
g2 = new GraphAdjMatrix();
g1.addEdge(1,2);
g2.addEdge(1,2);
通过多态性,您可以调用两个不同的函数,但得到的结果与 Graph 的客户端相同。
另一个现实生活中的例子是汽车刹车。作为汽车客户,厂家给你一个踏板让你踩,不知道后端的刹车是怎么实现的。它可以是后部的鼓式制动器或盘式制动器。你只需要踩下刹车!
You are going to get access to the code once you implement the class/interface and you will modify it according to your need.
我想您对这里的语言给您的概念有点困惑 Abstraction
。您始终可以访问自己的代码,但 Abstraction
或 Polymorphism
之类的内容为您提供了理想的方式。所以在 Abstraction
中你只是说我知道会有一个名为 someThing
的行为作为抽象方法,但现在你不知道它会如何表现,实施者会告诉我们这将是怎样的。请参阅以下代码。
abstract class Game{
public abstract void play();
}
class Football extends Game{
@Override
public abstract void play(){
// write how football play
}
}
class Cricket extends Game{
@Override
public abstract void play(){
// write how Cricket play
}
}
我在这里给你留个问题。
Why you are making class level attributes public/protected/private although you have access to the code when you implement?
我认为你对两件事感到困惑
- OOP 中的抽象概念及其在 Java
中的实现
在java
中摘要class
Abstract : OOPs 的概念叫做 Abstract。在这里,用户可以捕获对象的必要特征。这个抽象概念实现为 class 和 java 中的对象。因此,当您以 class 的形式捕获对象的重要特征时,数据隐藏就会出现问题,这些特征只能由它们自己的 class 的对象访问。在这里,您从 class/world 外部隐藏了 class 的所有功能。所以,它被称为数据隐藏
abstract class : 这是 Java 实现的特征。如果你不知道完整的实现,那么你可以去抽象 class of java.
希望这能帮助你理解一点
谢谢
我对 java 中的抽象有点困惑。
我查了很多页面说抽象就是数据隐藏(隐藏实现)。
我对抽象的理解是'partial implementation'。只需在摘要 class/interface 中定义您需要的内容,然后 extend/implement 然后添加您自己的功能。
我不明白这是怎么隐藏数据的?实施 class/interface 后,您将可以访问代码,并根据需要对其进行修改。
我查了很多问题,关于这方面的文章,但仍然对此感到困惑。
感谢任何帮助。 谢谢
数据隐藏是指您在不阅读文档的情况下无法理解API内部如何工作(例如,ArrayList
)。 API 创建者不提供任何访问底层数组的权限。
您向将要使用它的用户隐藏 API 实现。他们不应该担心它在内部是如何工作的,他们只对提供给他们的功能感兴趣。
关于那个 a good article。
您将 abstraction(编程模式)与 Java 语言的 abstract 关键字混淆了。尽管相似,但它们在语义上的相关性很小。
抽象 意味着您从使用 class 或方法的代码中隐藏实现细节。使用您的方法的代码不需要知道您正在实现一个列表,使用数组或动态指针或嵌入式数据库或文件系统中的文件。
abstract 用于标记 class 具有仅声明但未实现的方法。它是 "abstract",因为它们不能被实例化,你不能从这些 classes 中创建任何实例(但你可以从它们的具体子 classes 中创建它们)。
它不是对你隐藏信息,而是对你抽象的客户端。看看这个例子。
public class Demo {
Client client = new Client(new Implementation());
}
public interface Abtraction {
void doWork();
}
public class Implementation implements Abtraction{
@Override
public void doWork() {
//doingTheWork
}
}
public class Client{
private Abtraction theAbstraction;
public Client(Abstraction theAbstraction){
this.theAbstraction = theAbstraction;
}
}
class Client
不知道 Abstraction
的实现,这意味着 Demo
class 可以提供 [=12] 的不同实现=] 而不会弄乱 Client
.
数据隐藏 基本上是隐藏有关 class 的内部数据成员的详细信息,并且仅 排他性地 提供有关 class 访问它。
从而避免了来自应用程序中的其他classes或来自任何其他应用程序的不必要的渗透,这意味着其他classes无法直接访问私有成员变量。
因此,您可以通过这种方式抽象有关class的内部细节。
我不确定这是否回答了你的问题,但如果你谈论的是一般的抽象 classes,它们在那里为 child class 提供功能扩展它而 child class 不必知道或处理实现的所有细节(它对 child class 的用户隐藏)。
我们以汽车为例:
public abstract class Vehicle {
protected int _numberOfWheels;
public Vehicle() {
this._numberOfWheels = 4;
}
}
public class Truck extends Vehicle {
public int carryingLoad;
public Truck() {
this.carryingLoad = 4000; // kg or something
}
}
所以 vehicle 是车辆的一个抽象实例 object 并且已经具有一些与之关联的功能,例如车轮的数量。这是一个受保护的方法,所以如果我创建一个新的卡车实例:
// Inside main
Truck truck = new Truck();
我无法更改轮子的数量,但是,如果我要在 class 中为卡车编写函数,例如:
// Inside the Truck class
public void addSpareTire() {
this._numberOfWheels++;
}
这样我就可以这样称呼它:
// Inside main
truck.addSpareTire();
我仍然可以与一些变量进行交互,但只能遍历扩展抽象 class 的 class 中的函数。我可以通过调用 addSpareTire()
一次添加一个轮胎,但我永远无法从我正在 使用 [=16] 的主函数直接与 _numberOfWheels
交互=]object,但我可以从Truck
class声明里面。来自卡车object的用户,该信息是隐藏。
我不知道这是不是你要的。希望这有帮助。
在面向对象编程中抽象是对用户隐藏实现细节的过程,只有功能会提供给用户。换句话说,用户将获得有关对象做什么的信息,而不是它如何做的信息。
查看以下内容 link 了解更多详情: http://www.visionsdeveloper.com/tutorial/java/java-abstraction.jsp
也许一个例子能更好地帮助你。假设你想实现一个图 class,它可能有邻接表或邻接矩阵来表示它的节点。所以抽象地说,你至少要 "addNode" "addEdge" 这个图:
public abstract class Graph
{
public abstract int addNode();
public abstract void addEdge(int from, int to);
}
现在您可以扩展两个 classes:
public class GraphAdjList extends Graph
{
private Map<Integer,ArrayList<Integer>> adjListsMap;
public int addNode()
{
//list based implementation
}
public void addEdge(int from, int to)
{
//list based implementation
}
}
public class GraphAdjMatrix extends Graph
{
private int[][] adjMatrix;
public int addNode()
{
//matrix based implementation
}
public void addEdge(int from, int to)
{
//matrix based implementation
}
}
当你从这两个 classes 调用 addEdge 中的任何一个时,你不必担心它背后的数据结构,你只知道你得到了你需要的结果,例如:
Graph g1,g2;
g1 = new GraphAdjList();
g2 = new GraphAdjMatrix();
g1.addEdge(1,2);
g2.addEdge(1,2);
通过多态性,您可以调用两个不同的函数,但得到的结果与 Graph 的客户端相同。
另一个现实生活中的例子是汽车刹车。作为汽车客户,厂家给你一个踏板让你踩,不知道后端的刹车是怎么实现的。它可以是后部的鼓式制动器或盘式制动器。你只需要踩下刹车!
You are going to get access to the code once you implement the class/interface and you will modify it according to your need.
我想您对这里的语言给您的概念有点困惑 Abstraction
。您始终可以访问自己的代码,但 Abstraction
或 Polymorphism
之类的内容为您提供了理想的方式。所以在 Abstraction
中你只是说我知道会有一个名为 someThing
的行为作为抽象方法,但现在你不知道它会如何表现,实施者会告诉我们这将是怎样的。请参阅以下代码。
abstract class Game{
public abstract void play();
}
class Football extends Game{
@Override
public abstract void play(){
// write how football play
}
}
class Cricket extends Game{
@Override
public abstract void play(){
// write how Cricket play
}
}
我在这里给你留个问题。
Why you are making class level attributes public/protected/private although you have access to the code when you implement?
我认为你对两件事感到困惑
- OOP 中的抽象概念及其在 Java 中的实现
在java
中摘要class
Abstract : OOPs 的概念叫做 Abstract。在这里,用户可以捕获对象的必要特征。这个抽象概念实现为 class 和 java 中的对象。因此,当您以 class 的形式捕获对象的重要特征时,数据隐藏就会出现问题,这些特征只能由它们自己的 class 的对象访问。在这里,您从 class/world 外部隐藏了 class 的所有功能。所以,它被称为数据隐藏
abstract class : 这是 Java 实现的特征。如果你不知道完整的实现,那么你可以去抽象 class of java.
希望这能帮助你理解一点
谢谢