Java封装、继承和多态

最新推荐文章于 2024-10-05 16:17:28 发布

「已注销」

最新推荐文章于 2024-10-05 16:17:28 发布

阅读量1.8w

点赞数 9

分类专栏： ------1.1 Java基础文章标签： Java基础知识

本文链接：https://blog.csdn.net/wu371894545/article/details/53316117

版权

------1.1 Java基础专栏收录该内容

7 篇文章 0 订阅

订阅专栏

前言：我想看看自己到底能走多远。

之前学习过封装、继承和多态，先总结如下

一、封装

1 什么是封装？

把客观的事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或对象进行操作，对不可信的进行信息隐藏。

2.为什么要用到封装？

说白点，我们之所以要用到封装，就是为了防止有人恶意修改你的数据。

我们来看下面一个列子你就明白了

Cat.height=25;

你可以把这件事情看作是直接通过远程控制修改Cat的实例变量。若远程控制落入了不当之人的手上，变量就可能变成杀伤力极强的武器。因为你无法

阻止下面的操作：

Cat.height=0;

这一定很糟糕。所以我们需要创建Setter这个方法给所有的实例变量，并寻求某种方法强制其他程序必须通过Setter来设置变量而不是直接的存取。

3.封装的基本原则？

要将程序的实现从不良数据修改成可以保护数据且让你还能修改数据的方式是很简单的。

所以要如何隐藏数据呢？

封装的基本原则：

3.1 将你的实例变量标记为私有private

3.2 提供共有的getter与setter来控制存取动作

这种做法能维持住安全性。

封装GoodDog

public class GoodDog {
    private int size;                 //将实例变量设置为private
    public int getSize(){             //将getter设定为public
    	return size;
    }
    public void setSize(int s){        //将setter设定为public
    	size=s;
    }
    
    void bark(){
    	if(size>60){
    		System.out.print("Woof!");
    	}else if(size>15){
    		System.out.print("Roof!");
    	}else{
    		System.out.print("Yip!");
    	}
    	
    }
}

运行查看结果

public class GoodDogTest {

	public static void main(String[] args) {
              GoodDog one = new  GoodDog();
              one.setSize(70);
              GoodDog two = new  GoodDog();
              two.setSize(8);
              System.out.print("Dog one: "+one.getSize());//70
              System.out.print("Dog two: "+two.getSize());//8
              one.bark();//Woof!
              two.bark();//Yip!
	}

}

二、继承

1.什么是继承？继承的特点？

子类继承父类的特征和行为，使得子类具有父类的各种属性和方法。或子类从父类继承方法，使得子类具有父类相同的行为。

特点：在继承关系中，父类更通用、子类更具体。父类具有更一般的特征和行为，而子类除了具有父类的特征和行为，还具有一些自己特殊的特征和行为。

在继承关系中。父类和子类需要满足is-a的关系。子类是父类。

表示父类和子类的术语：父类和子类、超类和子类、基类和派生类，他们表示的是同一个意思。

2.为什么需要继承？什么时候应该继承？

使用继承可以有效实现代码复用，避免重复代码的出现。定义出了共同的协议。

当两个类具有相同的特征（属性）和行为（方法）时，可以将相同的部分抽取出

3.怎么实现继承？

用extends（扩展）关键字来表示一个类继承了另一个类。

在父类中只定义一些通用的属性和方法。

子类自动继承父类的属性和方法，子类中可以定义特定的属性和方法。或子类重新定义父类的属性、重写父类的方法可以获得与父类不同的功能。

4、什么是方法重写？

如果在子类中定义的一个方法，其名称、返回类型及参数列表正好与父类中某个方法的名称、返回类型及参数列表相匹配，那么可以说，子类的方法重写了父类的方法。

方法重写在不同类，是实现多态的必要条件。

5、 super关键字的用法和位置，super关键字调用父类的构造方法，super关键字调用父类的方法？

在子类的构造方法中，通过super关键字调用父类的构造方法。

如果子类中重写了父类的方法，可以通过super关键字调用父类的方法。

父类：

private String name;

private String sex;

public xinxin1(String name,String sex)

{

this.name=name;

this.sex=sex;

}

public void hello(){

System.out.println(“嗨！我是”+name+”我是”+sex+”孩”);

}

子类：

public xinxin2(String name,String sex)

{

//调用父类的构造方法

super(name,sex);

}

public void hello(){

System.out.println(“我是新来的！”);

//调用父类的方法

super.hello();

}

位置注意：调用父类的构造方法的语句（super语句）必须是构造方法中的第一条语句。

因为创建对象的时候，需要先创建父类对象，再创建子类对象。

注意：创建对象时，先创建父类对象，在创建子类对象。如果没有显示调用父类的构造方法，将自动调用父类的无参构造方法。

三、多态

1.什么是多态？

多态的特征是表现出多种形态，具有多种实现方式。或者多态是具有表现多种形态的能力的特征。或者同一个实现接口，使用不同的实例而执行不同的操作。

2.为什么要使用多态？使用它的好处在哪里？

可以增强程序的可扩展性及可维护性，使代码更加简洁。

不但能减少编码的工作量，也能大大提高程序的可维护性及可扩展性。

3.如何实现多态？

一般做法是：写一个方法，它只接收父类作为参数，编写的代码只与父类打交道。调用这个方法时，实例化不同的子类对象（new 一个对象）。

更具体的说：

（1）、子类重写父类的方法。使子类具有不同的方法实现。

（2）、把父类类型作为参数类型，该父类及其子类对象作为参数转入。

（3）、运行时，根据实际创建的对象类型动态决定使用那个方法。

在运行时，java虚拟机会根据实际创建的对象类型决定使用那个方法。一般将这称为动态绑定。

我们来看看下面多态的例子：

    Animal[]  animals=new Animal[5];
        animals[0]=new Dog();
        animals[1]=new Cat();
        animals[2]=new Wolf();
        animals[3]=new Hippo();
        animals[4]=new Lion();//你可以放任何Animal类型的子类对象进去
for(int i=0;i<animals.length;i++){
	//这就是多态最强的地方，你可以将数组的元素逐个调出来当作是Animal来操作
	animals[i].eat();//当i为0时，这会调用Dog的eat()
	animals[i].roam();//当i为1时，这会调用Cat的roam()
}

好了，关于封装、继承和多态我们就讲完了。