day_09_Java类的封装、继承与多态

星期二, 十一月 10, 2015 10:34:07

 

 

封装

 

继承

  可以从一个简单的类继承出相对复杂高级的类

 

多态

      可以动态的对对象进行调用，使对象之间变得相对独立。

 

 

一:类的封装性

 

1.看下面的案例、

 

 ----1.1代码案例:

package day09;

 

public class CapsulationTest {

public static void main(String[] args) {

Person p = new Person();

p.age = -23;

p.name = "宇宙歆儿";

p.talk();

}

}

 

class Person {

String name;

int age;

Person() {

}

 

public void talk() {

System.out.print("我的名字叫:"+name+"\n"+"年龄:"+age);

}

}

 

运行结果:

我的名字叫:宇宙歆儿

年龄:-23

 

 

注意:

加工的原料有问题，生产出来的也有问题。

而导致这种错误的原因是，就是因为程序在原料的入口没有校验。

 

 

----1.2.类的封装实例

 

        之前所列举的程序都是用对象直接访问类中的属性，这在面向对象法则中是不允许的。

所以为了避免程序中这种错误的发生，在一般的的开发中往往要将类中的属性封装(private)。

 

代码案例:

package day09;

 

public class CapsulationTest {

public static void main(String[] args) {

Person p = new Person();

p.age = -23;

p.name = "宇宙歆儿";

p.talk();

}

}

 

class Person {

private String name;//设置为private

private int age;//设置为private

Person() {

}

 

public void talk() {

System.out.print("我的名字叫:"+name+"\n"+"年龄:"+age);

}

}

 

结果:

p.age = -23;

p.name = "宇宙歆儿";

 

直接对对象的属性进行访问，出现报错。是因为设置的属性为private，不可以直接对其进行访问。

 

注意:

     为私有的，不可以直接访问，这样就可以保证对象无法直接去访问类中的属性。

 

但是如果非要给对象赋值的话，解决方法是:

    会增加一些方法，如 setXxx()、 getXxx()这样的公用方法来解决这一矛盾。

 

----1.3自己总结：

 

1.通过set方法进行将privat的值改变

  改变完了还是private的修饰符

 

2.要使用get方法取出私有属性的值

  然后转换为外部可访问的值。

 

 

----1.4代码案例:

package day09;

 

public class CapsulationTest {

public static void main(String[] args) {

Person p = new Person();

p.setName("宇宙歆儿");

p.setAge(3);

/*p.getAge();

p.getName();*/

p.talk();//这个不用调用get是因为talk()已经可以访问了

}

}

 

/*setXxx()、 getXxx()为了解决:

    但是如果非要给对象赋值的话，解决方法是:

    会增加一些方法，如 setXxx()、 getXxx()这样的公用方法来解决这一矛盾。*/

class Person {

private String name;

private int age;

Person() {

}

 

public void talk() {

System.out.print("我的名字叫:"+name+"\n"+"年龄:"+age);

}

 

public void setName(String name) {

   this.name = name;

}

 

public void setAge(int a) {

if (a > 0) {

this.age = a;

}

}

 

public String getName() {

return name;

}

 

public int getAge () {

return age;

}

}

运行结果:

我的名字叫:宇宙歆儿

年龄:3

 

在set中设置了判断合理性

，设置age = -23

 

运行结果:

我的名字叫:宇宙歆儿

年龄:0

age为默认值0，可以保证数据的安全性。

 

 

注意:

 

    关于封装与否并没有明确的规定，不过从程序设计的角度来说，一般来说设计较好的程序的类中的属性都是需要封装的。

 

此时则只能使用setXxx()、getXxx()方法，这是一个明确的标准的规定。

 

 

将属性进行私有化

 

----1.5封装的优点：

 

   （1）隐藏类的实现细节；

   （2）让使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作；

   （3）便于修改，增强代码的可维护性；

 

 

 

二.类的继承

 

  类的继承可以以既有类为基础，进而派生出新的类。

通过这种方式，便能快速地开发出新的类，

而不是编写相同的程序代码，这就是程序代码再利用的概念。

 

----2.1继承的基本概念

 

 

在Java中，通过继承可以简化类的定义，扩展类的功能。

在Java中支持类单继承和多继承，但是不支持多继承，

即一个类只能继承一个类而不能继承多个类。

 

继承的格式:

    class 子类名 extends 父类

 

 

 

Java继承

-----只能直接继承父类中的公有属性和公有方法，

而隐含地(不可见地)继承了私有属性。

 

----2.2类的继承的实例

 

代码案例:

package day09;

 

public class InheritTest {

public static void main(String[] args) {

Student s1 = new Student();

   s1.setName("瓦询");

   s1.setAge(24);

   s1.setSchool("丰趣海淘");

   System.out.println(s1.getName()+"\n"+s1.getAge()+"\n"+s1.getSchool());

}

}

 

class Person{

private String name ;

private int    age;

public void setName(String name) {

this.name = name;

}

public String getName() {

return name;

}

public void setAge(int age) {

this.age = age;

}

public int getAge() {

return age;

}

}

 

class Student extends Person {

private String school;

 

public void setSchool(String school) {

this.school = school;

}

 

public String getSchool() {

return school;

}

}

 

 

运行结果:

瓦询

24

丰趣海淘

 

注意:

    在Java中只允许单继承，而不允许多重继承，也就是说一个子类只能有一个父类。

但是Java中却允许多层继承。A<--B<--C

 

 

 

----2.3.类的继承专题研究

 

关于继承的问题，有一些概念和过程需要澄清，有些语法和术语需要熟练掌握。本节做一些总结。

 

2.3.1子类对象的实例化过程

 

结论:

    子类对象在实例化时会默认先去调用父类中的无参构造方法，之后再调用本类中的相应的构造方法。

 

代码案例:

package day09;

 

public class InheritTest {

public static void main(String[] args) {

Student s1 = new Student();

}

}

 

class Person{

String name ;

int    age;

public Person() {

System.out.print("public Person()"+"\n");

}

}

 

class Student extends Person {

String school;

public Student() {

/*super();*/

System.out.print("public Student()");

}

}

 

运行结果:

public Person()

public Student()

 

2.3.2 super关键字

 

结论:

    super主要的功能时完成子类调用父类中的内容，也就是调用

父类中的属性或方法。

 

 

注意:

   用super调用父类中的构造方法，只能放在程序的第1行。

 

代码案例:

/*用super调用父类中的构造方法*/

package day09;

 

public class InheritTest {

public static void main(String[] args) {

Student s1 = new Student();

s1.school = "海淘";

System.out.print("姓名:"+s1.name+"\n年龄: "+s1.age+"\n学校:"+s1.school);

}

}

 

class Person{

String name ;

int    age;

public Person(String n,int a) {

this.name = n ; 

this.age = a;

}

}

 

class Student extends Person {

String school;

public Student() {

super("宇宙歆儿7",25);

}

}

 

运行结果:

姓名:宇宙歆儿7

年龄: 25

学校:海淘

 

super关键字不仅可用于调用父类中的构造方法，也可用于调用父类中的属性和方法。

 

格式:

   super.父类中的属性；

   super.父类中的方法()

 

2.3.3通过super调用父类的属性和方法

 

代码案例:

 

package day09;

 

public class InheritTest {

public static void main(String[] args) {

Student s1 = new Student("刘惜君",28,"恋风恋歌");

System.out.print(s1.school);

}

}

 

class Person{

String name ;

int    age;

public Person() {

}

 

public String talk() {

return "...名称:"+name+"\n年龄:"+age;

}

 

}

/*通过super调用父类的属性和方法*/

class Student extends Person {

 

String school;

public Student(String name,int age,String school) {

super.name = name;//在这里使用super进行调用父类的属性

super.age = age;

System.out.println(super.talk());//调用父类中的方法

this.school = school;//调用本类中的属性

}    

}

 

运行结果:

...名称:刘惜君

年龄:28

恋风恋歌

 

本例中，super换成this也是可以的，那为什么还要用super呢?

----见下例

 

2.3.4.限制子类的访问

 

  有些时候，父类并不希望子类可以访问自己的类中全部的属性和方法，所以需要将一些属性与方法隐藏起来，不让子类去使用。

为此可在声明属性或方法时加上“private”关键字，表示私有。

 

代码案例:

 

package day09;

 

public class InheritTest {

public static void main(String[] args) {

Student s = new Student();

s.setVar();

System.out.println("名称:"+s.getName()+"\n"+s.getAge());

}

}

 

class Person{

private String name ;

private int    age;

 

public void setName(String name) {

this.name = name;

}

public String getName() {

return name;

}

public void setAge(int age) {

this.age = age;

}

public int getAge() {

return age;

}

}

 

class Student extends Person {

public void setVar() {

super.setName("宇宙");

super.setAge(1111);

}

}

 

运行结果:

名称:宇宙

年龄:1111

 

2.3.5最后注意 super 与 this 的区别：

 

        super 不是一个对象的引用，

       不能将 super 赋值给另一个对象变量，

      它只是一个指示编译器调用父类方法的特殊关键字。

 

super 关键字的功能：

调用父类中声明为 private 的变量。

点取已经覆盖了的方法。

作为方法名表示父类构造方法。

 

2.3.6代码案例:

package day09;

 

public class InheritTest {

public static void main(String[] args) {

Student s = new Student();

s.setVar();

}

}

 

class Person{

private String name = "jami soul she";

 

public String getName() {

return name;

}

}

 

class Student extends Person {

public void setVar() {

// 通过 getter 方法调用父类隐藏变量

     System.out.println(super.getName());

}

}

 

运行结果:

jami soul she

 

 

----4.覆盖

 

在程序中可以看到，在子类中可以通过super.方法()调用父类中被子类覆盖的方法。

 

代码案例:

/*验证在遇到方法的覆盖时，可以使用super调用父类的方法 */

package day09;

 

public class InheritTest {

public static void main(String[] args) {

Student s = new Student("五月天",32,"五迷五迷");

System.out.print(s.talk1());

}

}

 

class Person{

String name ;

int age;

public String talk1() {

return "姓名="+name+"\n年龄="+age;

}

}

 

class Student extends Person {

String school;

 

public Student(String name,int age,String sc){

this.name = name;

this.age = age;

this.school = sc;

}

public String talk1() {

/*不加这个的话，父类的talk1()方法不会被执行，因子类已经进行了方法的覆盖*/

return super.talk1()+"\n公司="+school;

}

}

 

运行结果:

姓名=五月天

年龄=32

公司=五迷五迷

 

 

三.类的多态

 

最重要的一个特性---多态

 

----3.1 多态的基本概念

 

重载的最终效果是调用同一个方法名称，却可以根据传入的参数不同的处理结果，这其实就是多态的一种体现。

 

 

代码案例:

package day09;

 

public class PolymorphismTest {

public static void main(String[] args) {

 

/*父类的对象通过子类进行的实例化，

* 所以在调用fun1（时，

* 调用的是子类的次方法*/

Person p = new Student();

p.fun1();

p.fun2();

}

}

 

class Person {

public void fun1() {

System.out.println("1.fun1()");

}

public void fun2() {

System.out.println("2.fun2()");

}

}

 

class Student extends Person{

//进行覆盖父类的fun1()方法

public void fun1() {

System.out.println("3.fun1()");

}

public void fun4() {

System.out.println("4.fun4()");

}

}

运行结果:

3.fun1()

2.fun2()

 

 

      案例的原因是因为父类对象并非由其本身的类实例化，而是通过子类实例化

这就是所谓的对象的多态性，即子类实例化对象可以转换为父类实例化对象

 

星期二, 十一月 10, 2015 19:22:18   Java从入门到精通P182

 

----3.2 类的多态实例

 

在这里要讲解两个概念，予以重视。

 

3.2.1向上转型

 

向上转型

在上个例子中，父类对象通过子类对象去实例化，实际上就是对对象的向上转型。

向上转型是不需要进行强制类型转换的，但是向上转型会丢失精度。

 

向下转型

就是父类的对象可以转换为子类对象，但是需要注意的是，

这时则必须要进行强制的类型转换。

 

总结:

 

1.向上转型可以自动完成

2.向下转型必须进行强制类型转换

 

注意:

 

 

并非全部的父类对象都可以强制转换为子类对象。

代码案例:

package day09;

 

public class PolymorphismTest {

public static void main(String[] args) {

 

/*父类的对象通过子类进行的实例化，

* 所以在调用fun1（时，

* 调用的是子类的次方法*/

 

/*Person p = new Person();

将p向下转型:

* 父类用其本身类实例化自己的对象，

* 但它并不知道谁是自己的子类，

* 那肯定在转换时会出现错误。

* Exception in thread "main" java.lang.ClassCastException:

*  day09.Person cannot be cast to day09.Student

at day09.PolymorphismTest.main(PolymorphismTest.java:11)

Student p2 = (Student)p;

*/

 

Person p = new Student();//p为person的子

Student p2 = (Student)p;

p2.fun1();

p2.fun2();

 

 

 

}

}

 

class Person {

public void fun1() {

System.out.println("1.fun1()");

}

public void fun2() {

System.out.println("2.fun2()");

}

}

 

class Student extends Person{

//进行覆盖父类的fun1()方法

public void fun1() {

System.out.println("3.fun1()");

}

public void fun3() {

System.out.println("4.fun3()");

}

}

 

运行结果:

3.fun1()

2.fun2()

 

问题总结:

 

   父类用其本身类实例化自己的对象，但它并不知道谁是自己的子类，那肯定在转换时

会出现错误。

 

修改方法:

  将实例化代码改为Person p = new Studengt();

这样就是由子类去实例化父类对象，

也就是说这个时候父类知道有这么一个子类，也就是相当于父亲知道自己有这么一个孩子。

所以下面再进行转换时就不会再有问题。

 

星期二, 十一月 10, 2015 20:08:41