java编程-面向对象---继承和多态
2008-10-13 23:50
585 查看
(参考http://java.chinaitlab.com/List_186_17.html)
class Animal
{
private int weight;
public int getWeight()
{
return weight;
}
public void setWeight(int w)
{
weight=w;
}
}
class Dog extends Animal
{
/**
*子类新增方法
*/
public void Bark()
{
System.out.println("Wang~~Wang~~~");
}
}
public class aaa
{
//private static Dog myDog;
public static void main(String args[])
{
Dog myDog;
myDog=new Dog();
myDog.setWeight(50);
System.out.println("My Dog's Weight is"+myDog.getWeight());
myDog.Bark();
}
}
A variable that can hold a reference to an object of class A can
also hold a reference to an object belonging to any subclass of
A.(一个能指向类A的对象变量也可以指向类A的子类的对象)
Vehicle myVehicle ;
Vehicle myVehicle = new Car(); //ok
父类对象 子类对象
myCar = myVehicle; // wrong!
子类对象 父类对象
myCar = (Car)myVehicle;//ok
if (myVehicle instanceof Car) ...
下面我们来看一下,经常用到的重要概念,也就是java语言的的OOP特性,这是对于OOP而言的,不含前面的OOA和OOD的。因为是初学嘛,还没有学到怎么分析和设计呢。Java的OOP有三大特性:封装、继承、多态。
封装的概念已经说过了,我们讲的是,它用权限修饰符private使得属性不能被外界访问,像是人的五脏六腑怎么能让人随意的碰呢?人的这个属性也是要封装的。如有再不明白,请访问我们的技术论坛 。
说一下容易理解的继承:
当一个类是另一个类的特例时,这两个类之间具有父子类的关系。子类继承了父类的方法和属性,就是说子类可以重用父类中的这部分代码。比如:轿车是车的一个特例。轿车是车的子类。就是说,轿车继承了车的一切特性。继承用关键字extends表示。
实践:
对于继承来说,很容易理解因为你就看字面的意思就知道它是继承着父类的特性。多态字面不容易理解了。下面我们具体讲一下吧!
类之间的继承关系使子类具有父类的所有变量和方法,=> 父类所具有的方法也可以在它所有子类中使用,发给父类的消息也可以发送给子类 => 子类的对象也是父类的对象=>子类的对象既可以做本身的类型,也可以做父类的类型。 呵呵,上述推导公式好像绕口令似的。我们举个例子理解上述概念。举例:
public class 动物 //动物是父类
public class 猫 extends 动物 //猫是子类
动物的所有特性在猫中可以使用,发给动物的信息猫也能收到=>猫的对象new 猫();既可以作为本身的类型 猫 a=new 猫(); 也可以作为父类的类型 动物 b = new 猫();这样说理解了吗?如有疑问请访问我们的技术论坛。
如果大家明白了的话,我们就可以从上述公式推导出结论,所有的子类都可以作为父类的类型(同一种类型)来对待。像刚才那个动物有很多子类啊,可以有很多对象。动物 a=new 猫();动物 b=new 狗(); 动物 c=new 猪();。这样的将子类型的对象引用转换成父类型的对象引用,叫做上溯造型(upcasting)。
我们再来引伸一下,我们在数组那节课里讲了,数组存放的元素是相同类型的数据,但是上溯造型使得java允许创建不同类型对象的数组。例如:
夷?这是怎么回事啊,数组里面不是相同类型吗?对啊,因为Sectetary和Manager是Employee的子类,所以也可以通过上溯造型变成Employee啊。以前我们还学到了所有对象都是从java.lang.Object 继承下来的。如果数组要是 Object型的话 Object[] obj=new Object[];那就是里面放什么对象都行了。因为什么对象都可以是Object型的。
实践:
Java的多态性,有什么意义呢?它的突出优点是使程序具有良好的扩展性。它通过继承,可以派生出任意多个新类型,或向基类增加更多方法时,无须修改原有对基础类进行处理的相关程序。就是扩展性好。
我们返回再看面向对象(专指OOP)的这三个特性封装、继承、多态三者的关系。没有封装就没有继承,没有继承就没有多态。
abstract class shape{
int x,y;
String color;
public shape(){
x=0;
y=0;
}
public shape(int xx,int yy){
x=xx;
y=yy;
}
void setColor(String str){
color=str;
}
abstract double getArea();
}
class Rect extends shape{
public Rect(int xx,int yy){
super(xx,yy);
}
double getArea(){
return x*y;
}
}
class oval extends shape{
public oval(int xx,int yy){
super(xx,yy);
}
double getArea(){
return 0.5*x*x*y*y;
}
}
class aaa{
public static void main(String[] args){
// shape sh=new shape(10,10);
Rect rc=new Rect(10,10);
System.out.println(rc.getArea());
oval ov=new oval(20,10);
System.out.println(ov.getArea());
}
}
class Animal
{
private int weight;
public int getWeight()
{
return weight;
}
public void setWeight(int w)
{
weight=w;
}
}
class Dog extends Animal
{
/**
*子类新增方法
*/
public void Bark()
{
System.out.println("Wang~~Wang~~~");
}
}
public class aaa
{
//private static Dog myDog;
public static void main(String args[])
{
Dog myDog;
myDog=new Dog();
myDog.setWeight(50);
System.out.println("My Dog's Weight is"+myDog.getWeight());
myDog.Bark();
}
}
A variable that can hold a reference to an object of class A can
also hold a reference to an object belonging to any subclass of
A.(一个能指向类A的对象变量也可以指向类A的子类的对象)
Vehicle myVehicle ;
Vehicle myVehicle = new Car(); //ok
父类对象 子类对象
myCar = myVehicle; // wrong!
子类对象 父类对象
myCar = (Car)myVehicle;//ok
if (myVehicle instanceof Car) ...
下面我们来看一下,经常用到的重要概念,也就是java语言的的OOP特性,这是对于OOP而言的,不含前面的OOA和OOD的。因为是初学嘛,还没有学到怎么分析和设计呢。Java的OOP有三大特性:封装、继承、多态。
封装的概念已经说过了,我们讲的是,它用权限修饰符private使得属性不能被外界访问,像是人的五脏六腑怎么能让人随意的碰呢?人的这个属性也是要封装的。如有再不明白,请访问我们的技术论坛 。
说一下容易理解的继承:
当一个类是另一个类的特例时,这两个类之间具有父子类的关系。子类继承了父类的方法和属性,就是说子类可以重用父类中的这部分代码。比如:轿车是车的一个特例。轿车是车的子类。就是说,轿车继承了车的一切特性。继承用关键字extends表示。
实践:
//这是基类 public class Che { private int wheel = 4; public int getWheel() { return wheel; } } public class Jiaoche extends Che { private String pinpai = "桑塔纳"; public String getPinpai() { return pinpai; } } public class Testche { public static void main(String[] args) { Jiaoche car = new Jiaoche(); int wheels = car.getWheel(); //调用基类的方法 String Pinpal = car.getPinpai();//调用本身的方法 System.out.println("车有 "+wheels+" 个轮子"); System.out.println("轿车的品牌是 "+Pinpal); } } |
类之间的继承关系使子类具有父类的所有变量和方法,=> 父类所具有的方法也可以在它所有子类中使用,发给父类的消息也可以发送给子类 => 子类的对象也是父类的对象=>子类的对象既可以做本身的类型,也可以做父类的类型。 呵呵,上述推导公式好像绕口令似的。我们举个例子理解上述概念。举例:
public class 动物 //动物是父类
public class 猫 extends 动物 //猫是子类
动物的所有特性在猫中可以使用,发给动物的信息猫也能收到=>猫的对象new 猫();既可以作为本身的类型 猫 a=new 猫(); 也可以作为父类的类型 动物 b = new 猫();这样说理解了吗?如有疑问请访问我们的技术论坛。
如果大家明白了的话,我们就可以从上述公式推导出结论,所有的子类都可以作为父类的类型(同一种类型)来对待。像刚才那个动物有很多子类啊,可以有很多对象。动物 a=new 猫();动物 b=new 狗(); 动物 c=new 猪();。这样的将子类型的对象引用转换成父类型的对象引用,叫做上溯造型(upcasting)。
我们再来引伸一下,我们在数组那节课里讲了,数组存放的元素是相同类型的数据,但是上溯造型使得java允许创建不同类型对象的数组。例如:
Employee[] staff = new Employee[3]; staff[0] = new Manager(); staff[1] = new Secretary(); staff[2] = new Employee(); |
实践:
// java中的多态 class Shape { void draw() {} void erase() {} } //圆形 class Circle extends Shape { void draw() { System.out.println("Circle.draw()"); } void erase() { System.out.println("Circle.erase()"); } } //正方形 class Square extends Shape { void draw() { System.out.println("Square.draw()"); } void erase() { System.out.println("Square.erase()"); } } //三角形 class Triangle extends Shape { void draw() { System.out.println("Triangle.draw()"); } void erase() { System.out.println("Triangle.erase()"); } } public class Shapes { public static Shape randShape() { switch((int)(Math.random() * 3)) { default: case 0: return new Circle(); case 1: return new Square(); case 2: return new Triangle(); } } public static void main(String[] args) { Shape[] s = new Shape[9]; // 向数组里添加类型 for(int i = 0; i < s.length; i++) s[i] = randShape(); // 用多态的方法调用 for(int i = 0; i < s.length; i++) s[i].draw(); } } |
我们返回再看面向对象(专指OOP)的这三个特性封装、继承、多态三者的关系。没有封装就没有继承,没有继承就没有多态。
abstract class shape{
int x,y;
String color;
public shape(){
x=0;
y=0;
}
public shape(int xx,int yy){
x=xx;
y=yy;
}
void setColor(String str){
color=str;
}
abstract double getArea();
}
class Rect extends shape{
public Rect(int xx,int yy){
super(xx,yy);
}
double getArea(){
return x*y;
}
}
class oval extends shape{
public oval(int xx,int yy){
super(xx,yy);
}
double getArea(){
return 0.5*x*x*y*y;
}
}
class aaa{
public static void main(String[] args){
// shape sh=new shape(10,10);
Rect rc=new Rect(10,10);
System.out.println(rc.getArea());
oval ov=new oval(20,10);
System.out.println(ov.getArea());
}
}
相关文章推荐
- Java 面向对象封装、继承、多态——编程思想总结
- Java基础笔记 – 面向对象三个特征 继承、封装、多态及编程细节提示
- 深入理解Java面向对象三大特性 封装 继承 多态
- 黑马程序员-Java的面向对象(抽象类、接口、内部类和继承、组合、多态)
- 牛客网Java刷题知识点之面向对象java的四大特性(抽象、封装、继承、多态)
- Java程序员从笨鸟到菜鸟之(二)面向对象之封装,继承,多态(上)
- Java的面向对象的三大特性 封装 继承 多态
- Java程序员从笨鸟到菜鸟之(二)面向对象之封装,继承,多态(上)
- 复习 1 java 面向对象之封装,继承,多态(1)
- Java入门笔记-(面向对象:封装,多态,继承)
- java面试题一:面向对象的特征:抽象,继承,封装,多态
- Java面向对象的三个基本特征:封装、继承、多态
- Java程序员从笨鸟到菜鸟之(二)面向对象之封装,继承,多态(上)
- java面向对象的特性 封装 继承 多态
- Java学习之旅基础知识篇:面向对象之封装、继承及多态
- java面向对象的三大基本特征之封装,继承,多态
- Java 基础(三) 继承 多态 -------面向对象的特殊性能
- java 中什么时候用抽象类,什么时候用 接口(面向对象的继承与多态)
- 面向对象——Java的封装、继承和多态
- Java语言中的面向对象特性:封装、继承、多态,面向对象的基本思想(总结得不错)