封装 和继承的 疑问!~

Question

封装的单位是对象; 继承的单位是类; 好象扯不上边;
可是对这句话不太理解; 被这些单位给搞晕了!~  请大家帮忙写这样一个程序:1.写一个类; 封装类的属性和部分方法; 并且封装构造方法; 写一个继承关系表示不冲突;2. 在类的内部生成对象封装; 在外部通过一个接口声明 去调用这个类的实例;
说的不太通顺,还请见谅, 希望能给予帮助, 谢谢!~~

Answer 1

封装的单位是对象;把多种对像封装在一个对像中public class FF
{
  private int i;//int类型的对像i
  pirvate String str;//String类型的对像str
}FF f = new FF();
f对像中有int对像,也有String类型的对像.都是针对i,str这样的对像的.还可以有其它的对像.
继承的单位是类; 只能是一个继承其它的类,不能说一个对像继承其它对像.A类继承B类,我也不懂怎么去描述,我只好把理解为Java规范的约定.继承就是类与类之间的.封就是说把多种类型(int.String等)的对像封装在一种类型对像(FF  f)中;

Answer 2

你以为一个Java类有多复杂呀???加几个get/set方法就行了.

Answer 3

楼主，你目前不适合去理解接口，等你把 数据的封装和隐藏想清楚了，然后去研究继承，然后研究多态，再之后再研究接口和面向接口编程。最后看我这个帖子。
http://topic.csdn.net/u/20071229/20/50c600d9-8369-4c75-a53b-73249696082b.html先扯什么是数据的封装，class Point
{
    int x;
    int y;
};
你先想这个，然后我们说数据的隐藏。class Point
{
    private int x ＝ 0;
    private int y ＝ 0;
}当然了，这样不够，
class Point
{
    private int x ＝ 0;
    private int y ＝ 0;
    public int getX() {}
    public int setX(int value) {}
    //... ...
}我们有了public的方法了，就可以操作x，y了，而且你不能使得x和y的值 离谱～。而且，我们看Rect类的设计。class Rect
{
    Point p1;//Top-Left point;
    Point p2;//Botton-Right point, 
}
这样是不是又一次诠释了什么是数据的封装。

Answer 4

欧洲有谚语，叫做 “有旧有新”，我们继承的目的就在于此。如果我们有一个类了，比如说是 一个 “按钮” 吧。class Button
{
    String text;
    Rect rect;
}
Java代码对付看了，就不写那些形象理解的部分了。那么当我们发现Windows左下角的开始菜单的那个Button很好看的时候，又不想全部重写关于Button已有的属性，状态，行为怎么办？继承是一种办法，是一种相当好的办法。class ImageButon extends Button
{
    Image image;
}
那么，ImageButton既有了Image，也有了text和它的区域Rect，对吧？
以后说多态。

Answer 5

多态就不是那么好说了，因为我们面向对象最核心的问题是对象的行为问题。
(那些觉得问题简单的人去思考这个问题，为什么正方形不能从矩形派生？)多态是关注对象行为的。我们有了Button类，假设它的一个行为是显示自己，于是我们有Code：class Button
{
    void show() { /* 想怎么show就怎么show */ }
}那么，我们的ImageButton怎么办啊？显然行为不同了，它要显示一个图片哦～class ImageButon extends Button
{
    void show() { /* 画图呗，哥们我还是研究过边缘检测的。 */ }
}从语法上说，这个完成了多态性的一部分了，先强调一下，这里面有继承(Inheritance)，有重写(Override)。现在我们完成这个多态的表述：Button btn = new ImageButton(/*some constructor params*/);
...
btn.show();//注意，这个show会调用到派生类的方法实现中，这个调用也被称为延迟绑定，C++叫动态绑定。
重申一下多态的概念，一个字都不要错哦，：
用基类的指针或者引用调用派生类的方法叫做动多态。(对于Java，我们就说引用就可以了。)

Answer 6

这是回答的什么吗!.. 完全不是所要问题的答案啊!~~~  我只要这么一段的例子程序代码?.  有这么难吗?..  为什么非要给我扯出来那么多废话呢?.. 难道我不是学java的吗?. 我不懂什么叫封装,什么叫继承?.
什么叫接口? 什么叫多态吗?.  我只要一个例子的应用; 显示封装对象的概念;  
你们在那里扯很多封装数据成员;   请按题解答; 不要来回答这些基础概念; 基础概念我到哪里都能找到;我要看的是一个实现!!!!!! 实现!!!!!!!!!!!!!!!!!!!!!  

Answer 7

楼上的回答其实很详细,也很有耐心,楼主如果不满意的话,可以继续提出来.
你在16楼的回复太冲动了,很打击大家的情绪呢.lz好象是在自学Java,很佩服楼主的自学精神和专研精神.我是这么认为的: 楼主要求的程序即使写出来,也体现不了封装,多态,继承 的这些显著特点.我就以我的理解来举一个例子，希望能简单的体现这3个特点:以楼主为例：
现在我们有一个CSDNer：bxdg42578670 
JAVA要自学通 
等 级：一个三角
-----------------------------------------------------------
我用一个抽象类把他的固有特点抽取出来：CSDNer.java 里面有属性的get和set方法，同样是抽象的，没有实现.
然后有一个楼主类继承自这个抽象类：楼主.javapublic abstract class CSDNer
{
  abstract所有属性对应的get和set方法;
}这样做有一个好处，所有楼主或新楼主，都继承自CSDNer，都必须实现CSDNer中应有的方法。
在实际项目中，架构师掌握和控制一个项目的重要方法，就是制定 接口和抽象类，普通类必须实现对应的接口和抽象类(一般是接口，约束性更强)，那么就都受到架构师的约束了。-----------------------------------------------------------
当我要使用楼主类的时候，我这么声明：public class 楼主资料
{
  public CSDNer get当前楼主()
  {
     /**
     * 这就是多态和继承的应用了，我以父类的名义声明，但实际实例化的是子类。
     */
    CSDNer 当前楼主 = new 楼主();
    return 当前楼主;
  }
}这么做有什么好处？
当我论坛中到处都有楼主的影子时(bxdg42578670的确很活跃来着).
我都调用 get当前楼主()方法，返回的是一个CSDNer.有一天楼主变了，成了一个新楼主，我代码的其他所有地方都不用变，只需要把楼主资料.java中的
CSDNer 当前楼主 = new 楼主();
改为
CSDNer 当前楼主 = new 新楼主();
其他地方都不用变.如果不使用继承和多态的特点，那么楼主资料返回了一个 楼主，当变化发生时，我需要把代码中所有有 楼主 的地方，换成 新楼主。-----------------------------------------------------------这里回头看继承和多态在例子中的应用：所有楼主和新楼主都继承自 CSDNer，使用时用CSDNer声明，保持了统一的格式。当楼主和新楼主互相替换时，只需要改变new 后面的实例就行，在代码中 楼主和新楼主 都继承自CSDNer(楼主资料返回的是CSDNer)代码没有太大变化。而且 楼主与新楼主 都实现了CSDNer的方法，那么代码中即使实例变了，但是 当前楼主.getID();的方法不发生变化:两个楼主的 getID()方法有统一的参数和返回值。

Answer 8

我所说的应该没有那么难理解吧!  我再解释一下:
意思就是说写一个类;  将这个类完全的封装; 并且在类的内部就new出对象;整个类也就只能诞生这么一个对象; 想new新的一个都做不到;外界只能通过一个接口声明; 来调用这个对象在外面使用;
我就想看下这样的一个例子啊!~~ 我是自己写不出来,才请教啊!大哥!~您就帮帮忙吧!~~~~~~

Answer 9

回18楼:所谓封装并不是说封装类,封装只是一个抽象的概念,一般的JavaBean类起到的作用之一,就是封装."意思就是说写一个类;将这个类完全的封装;"
------------------------------------
这个绝对不是封装的体现(至少不是主要的):封装的是数据,用类的结构代替数据的结构,用类的方法代替数据的行为.再举个例子,我要把楼主和小草的信息写入一个文件中.
面向过程的办法是向一个文件
write(bxdg42578670);
write(JAVA要自学通);
然后继续
write(healer_kx);
write(甘草);
存储和读取的,和楼主/小草没什么关系,都是一条条的String这里我把楼主和小草的资料封装起来
ICSDNer 数据1 = new CSDNer(bxdg42578670,JAVA要自学通);
ICSDNer 数据2 = new CSDNer(healer_kx,甘草);
最后我把对象写进文件里
write(数据1);
write(数据2);
当我需要的时候,读/写的单位就变成了CSDNer.
以一个一个的CSDN用户为基础单位进行操作.

Answer 10

"封装的单位是对象;继承的单位是类;"
---------------------------------我对这句话的理解和楼主不同,这里"对象"不是指Java内存中的对象,而是指现实世界中的对象.把现实世界中的对象,以某个类对象的形式存放起来.类的属性就是现实世界中的对象的属性,类的方法就是现实世界中的对象的行为.这就是封装.

Answer 11

总之你就写一个;  在外面使用的 对象; 只能在它本身类内部new出来的; 并且是唯一的;外界无法再去创建这个类的新的实例;  所有的都指向这一个对象;
--------------------------------------------------------------------------
我知道我有时候说的可能有口误;  也知道封装的单位是对象;  可能是新手的缘故吧!~也有可能是自学无法获及正规表达的原因吧!~~  
这个还需要更长时间的磨练吗!~ 你说对吧!~~

Answer 12

汗,楼主性子真拗.听描述很像是一个单例...
public class 楼主
{
  private static 楼主 当前楼主 = null;  //私有的一个楼主唯一实例的引用.
  private 楼主(){}                           //私有构造方法,外面都创建不了楼主了.  public staitc synchronized 楼主 get楼主()  //唯一获得楼主实例的方法.
  {
    if(this.当前楼主 = null)                 //引用为空,创建实例
    {
      this.当前楼主 = new 楼主();             //创建唯一实例
    }
    return 当前楼主;                         //返回楼主实例的唯一一个引用.
  }
}

Answer 13

楼主提的要求感觉上就是单例模式的要求啊...单例的实现一般是饿汉式或懒汉式,我上面写的是懒汉式.空手写的,不过应该没什么错.如果
private static 楼主 当前楼主 = new 楼主();
然后去掉if判断,就变成饿汉式了.所谓殊途同归,楼主虽然是自学,但是不经意间就踏入了江湖高手的行列,特此膜拜~~~``

Answer 14

你写的哪个类; 岂不每次 使用的时候都会去new ()  吗?. 看上去好象无法唯一啊?....

Answer 15

我QQ上全是和游戏啊,音乐和医疗相关的.群多而且刷屏厉害,一般不敢开.你有msn能留下吗?

Answer 16

检查了下,貌似没问题(话说我经常突发性的2起来)当前楼主这个唯一引用是 static的,当它的引用存在的时候,就不会new 而是直接返回存在的对象了.也就是说,get楼主()方法,只在第一次调用的时候,new一个楼主.

Answer 17

外面调用就是楼主 bxdg42578670 = 楼主.get楼主(); //第一次创建一个实例/** 
  * static的 当前楼主(即bxdg42578670引用的那个当前楼主)不为null ,它指向开始new的那一个对象
  * 那么get楼主()方法不会再去new一次,而是直接返回开始 new 的那个对象
  */
楼主 甘草 = 楼主.get楼主();  // 其实甘草 和 bxdg42578670 指向同一个对象.

Answer 18

汗,发现好多错首先去掉所有的this:当前楼主是static的
有一处static拼错了
还有,if里的判断用"==",我居然用了"="自我鄙视一下

Answer 19

我没用MSN ,心里有太多的问题; 也有可能学习方法不太正确吧!~要不你申请一个新的QQ, 干净; 没人;实在不行, 我申请去, 在这里给你发个消息 , 

Answer 20

public class NN {
public static void main(String[] args) throws Exception {
楼主 a = 楼主.get楼主();
楼主 b = 楼主.get楼主();
System.out.println(a==b);
}
}class 楼主
{
  private static 楼主 当前楼主 = null;  //私有的一个楼主唯一实例的引用.
  private 楼主(){}                           //私有构造方法,外面都创建不了楼主了.  public static synchronized 楼主 get楼主()  //唯一获得楼主实例的方法.
  {
    if(当前楼主 == null)                 //引用为空,创建实例
    {
      当前楼主 = new 楼主();             //创建唯一实例
    }
    return 当前楼主;                         //返回楼主实例的唯一一个引用.
  }
}没问题,输出为true;

Answer 21

楼主要实现的就是单例类！！！楼主所说的封装好像和java中的概念封装不是一个意思！ 单例类
 实现单例类有2中方法
 他们的共同点是 构造方法是private的
第一种方法：在类中提供public static final 成员变量。好处：性能稍微好点
第二中方法：在类中提供private static final 成员变量，然后提供public static 方法获取该实例。不改动api情况下，改动比较灵活第二个方法是所谓的饿汉式还有一个注意点：如果单例类需要序列化，那么一定要重写readResolve方法,保证反序列化出来的是一个实例

Answer 22

ACCP [using]~~Poject 5
理解下面的CODE就不用考虑OOP概念什么的了,直接上机练就OK了abstract class Animal //父类
{
public boolean mammal = true; //是否哺乳
public boolean carnivorous = true; //是否食肉
public int mood = 1; //情绪,默认好 public boolean isMammal() //显示是否哺乳方法
{
return this.mammal;
}
public boolean isCamivorous() //显示是否食肉方法
{
return this.carnivorous;
}
public void setMood(int mood) //设置情绪
{
this.mood = mood;
}
public int getMood() //显示情绪
{
return this.mood;
}
abstract public String sayHello(); //打招呼方式方法（未完成）
abstract public String sayHello(int mood); //带参打招呼方（未完成）}interface LandAnimal //陆生接口
{
public int getNumberOfLegs(); //有脚？（未完成）
}
interface WaterAnimal //水生接口
{
public boolean hasGill(); //有腮？（未完成）
public boolean laysEggs(); //有卵？（未完成）
}
//---------------------DOG------------------------------------class Dog extends Animal implements LandAnimal //狗类 -:-)继承,拥有Animal所有公属性和方法等!
{
private int numberOfLegs = 4; //狗脚默认4脚 -:-)封装,Dog自己的属性
Dog() //构造狗
{
this.mammal = true; //是哺乳
this.carnivorous = true; //是食肉
}
public String sayHello() //重写狗
{
return "摇摇尾巴";
}
public String sayHello(int mood) //带参重写狗
{
this.setMood(mood);
switch (mood)
{
case 1: //1为情绪好0为不好
return "旺旺旺叫";
case 0:
return "呜呜叫";
default:
return "摇摇尾巴";
}
}
public int getNumberOfLegs() //显示脚，接口实现ING
{
return this.numberOfLegs;
}
}
//---------------------CAT------------------------------
class Cat extends Animal implements LandAnimal //猫类实现陆生接口
{
private int numberOfLegs = 4; //猫脚4脚 Cat() //构造猫
{
this.mammal = true;
this.carnivorous = true;
}
public String sayHello() //重写猫
{
return "喵喵叫";
}
public String sayHello(int mood) //带参重写猫
{
this.setMood(mood);
switch (mood)
{
case 1: //1为情绪好0为不好
return "咕噜咕噜叫";
case 0:
return "嘶嘶叫";
default:
return "喵喵叫";
}

}
public int getNumberOfLegs() //显示脚，接口实现ING
{
return this.numberOfLegs;
}

}//-----------------------------蛙----------------------------
class Frog extends Animal implements LandAnimal,WaterAnimal //蛙类，水陆接口并现
{
private int numberOfLegs = 4; Frog() //构造蛙
{
mammal = false;
carnivorous = false;
}
public String sayHello() //重写蛙
{
return "呱呱呱";
}
public String sayHello(int mood)
{
this.setMood(mood);
switch (mood)
{
case 1:
return "呱呱呱";
case 0:
return "扑通一声跳入水中";
default:
return "呱呱呱";
}
}
public boolean hasGill()
{
return true;
}
public boolean laysEggs()
{
return true;
}
public int getNumberOfLegs()
{
return this.numberOfLegs;
}
}//******************************************************public class Program
{
public static void main(String[] args)
{
Dog dog=new Dog(); //实例狗
Cat cat=new Cat(); //实例猫
Frog frog=new Frog(); //实例蛙
if(dog.isMammal()) //判断MAMMAL
System.out.println("狗是哺乳动物");
else
System.out.println("狗不是哺乳动物吗?");
if(dog.isCamivorous()) //判断CAMIVOROUS
System.out.println("狗是肉食动物");
else
System.out.println("狗不是肉食动物吗?");
System.out.println("狗通常的情况下,和人打招呼的方式为:"+dog.sayHello());
System.out.println("狗被抚摸情绪好的时候,打招呼的方式是:"+dog.sayHello(1));
System.out.println("狗烦躁的时候会:"+dog.sayHello(0));
System.out.println("狗有" + dog.getNumberOfLegs() + "条腿");
System.out.println();
//---------------------------------------------------
if (cat.isMammal())
System.out.println("猫是哺乳动物");
else
System.out.println("猫不是哺乳动物吗?");
if(cat.isCamivorous())
System.out.println("猫是肉食动物");
else
System.out.println("猫不是肉食动物");
System.out.println("猫通常的情况下,和人打招呼的方式为:"+cat.sayHello());
System.out.println("猫情绪好的时候会:"+cat.sayHello(1));
System.out.println("猫烦躁的时候会:"+cat.sayHello(0));
System.out.println("猫有" + cat.getNumberOfLegs() + "条腿");
System.out.println();
//------------------------------------------------------
if (frog.isMammal())
System.out.println("青蛙是哺乳动物吗?");
else
System.out.println("青蛙不是哺乳动物");
if (frog.isCamivorous())
System.out.println("青蛙是肉食动物");
else
System.out.println("青蛙不是肉食动物");
System.out.println("青蛙通常的情况下,打招呼的方式为:"+frog.sayHello());
System.out.println("青蛙情绪好的时候会:"+frog.sayHello(1));
System.out.println("青蛙受到惊吓是会:"+frog.sayHello(0));
if (frog.laysEggs())
System.out.println("青蛙产卵");
else
System.out.println("青蛙不产卵?");
if (frog.hasGill())
System.out.println("青蛙有鳃");
else
System.out.println("青蛙没有鳃吗?");
System.out.println("青蛙有" + frog.getNumberOfLegs() + "条腿"); }
}