`

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

 

 

 

1
0
分享到:
评论

相关推荐

    传智播客_Java培训_毕向东_Java基础源代码day03

    7. **面向对象编程基础**:包括类的定义、对象的创建、封装、继承、多态等概念。虽然"day03"可能不会深入到这些高级概念,但会是后续学习的重点。 8. **异常处理**:Java的异常处理机制(try-catch-finally)用于...

    day12_code_java_

    这些实例通常会涵盖类的定义、对象的创建、方法的调用、继承、多态的实现等。同时,也会涉及到异常处理、集合的使用等Java编程中常见的场景。通过仔细阅读和运行这些代码,学习者可以巩固理论知识,提高编程技能。

    day13_Character_java_

    在处理字符时,Java提供了`Character`类,该类包含了大量静态方法,用于检查字符属性(如是否为字母或数字)、转换字符(如大小写转换)以及执行其他与字符相关的操作。例如,`Character.isLetter(char)`可以用来...

    传智博客_Java培训_毕向东_Java基础课件

    3. **面向对象**(day05面向对象.doc、传智播客_Java培训_毕向东_Java基础[03-面向对象].pdf):Java是一种面向对象的编程语言,这部分会讲解类、对象的概念,封装、继承、多态等面向对象的基本特性,以及构造器、...

    DMS_day01_am_java的dms项目_达内java课程dms项目上课代码_

    2. **面向对象编程**:DMS项目会涉及面向对象的设计思想,如封装、继承和多态,通过这些概念来构建模块化的代码结构。 3. **JDBC连接数据库**:Java中的JDBC API是连接和操作数据库的关键。学员需要了解如何加载...

    传智播客_Java培训_毕向东_Java基础源代码_day02

    了解类的定义、对象的创建以及封装、继承和多态的概念是进阶学习的关键。 9. **输入输出**:Java提供System.in用于标准输入,System.out.println()用于输出。此外,学会使用FileReader、FileWriter等类进行文件操作...

    传智播客_Java培训_毕向东_Java基础源代码day02

    了解类的定义、对象的创建、封装、继承和多态等概念,是Java学习的关键。 这个压缩包可能还包括了对以上知识点的实践案例,让学生通过编写和运行代码来加深理解。在实际学习过程中,应结合讲解和代码,动手实践,以...

    传智播客_Java培训_毕向东_Java基础源代码day04

    8. **继承与多态**:继承允许一个类(子类)从另一个类(父类)继承属性和方法,从而实现代码复用。多态则是子类可以替代父类,使程序更具灵活性和扩展性。 9. **异常处理**:Java提供了异常处理机制,通过try-...

    week4_code_javaprogramming_java_bluej_

    2. **面向对象**:Java是一种纯面向对象的语言,涉及类、对象、封装、继承、多态等核心概念。类是对象的蓝图,而对象是类的实例。 3. **异常处理**:Java中的异常处理是通过try-catch-finally语句来实现的,用于捕获...

    day10-code_java_frighten7x5_

    在Java编程语言中,多态性(Polymorphism)是面向对象编程的三大特性之一,另外两个是封装和继承。多态性允许我们使用一个接口来代表多种类型的对象,这大大提高了代码的灵活性和可扩展性。在这个"day10-code_java_...

    Java入门基础学习资料day09-10

    day06【类与对象、封装、构造方法】 day07【Scanner类、Random类、ArrayList类】 day08【String类、static关键字、Arrays类、Math类】 day09【继承、super、this、抽象类】 day10【接口、多态】 day11【final、权限...

    java-course-design.rar_Course Design_Java course_java com.course

    1. **Java基础知识**:首先,了解Java基础语法是必不可少的,包括数据类型、变量、运算符、控制结构(如if语句、for循环、while循环)、类与对象、继承、封装和多态等。这些是编写任何Java程序的基础。 2. **日期和...

    Wiley_Java in 60 Minutes a Day_2003

    2. **类与对象**:Java是一种面向对象的语言,书中会讲解类的概念,如何创建和实例化对象,以及封装、继承和多态这三大面向对象特性。 3. **数组**:介绍如何声明和操作单维和多维数组,以及数组在内存中的存储方式...

    Java入门基础学习资料day11

    day06【类与对象、封装、构造方法】 day07【Scanner类、Random类、ArrayList类】 day08【String类、static关键字、Arrays类、Math类】 day09【继承、super、this、抽象类】 day10【接口、多态】 day11【final、权限...

    Java入门基础学习资料day07-08

    day06【类与对象、封装、构造方法】 day07【Scanner类、Random类、ArrayList类】 day08【String类、static关键字、Arrays类、Math类】 day09【继承、super、this、抽象类】 day10【接口、多态】 day11【final、权限...

    Java入门基础学习资料day01-02

    day06【类与对象、封装、构造方法】 day07【Scanner类、Random类、ArrayList类】 day08【String类、static关键字、Arrays类、Math类】 day09【继承、super、this、抽象类】 day10【接口、多态】 day11【final、权限...

    Java入门基础学习资料day05-06

    day06【类与对象、封装、构造方法】 day07【Scanner类、Random类、ArrayList类】 day08【String类、static关键字、Arrays类、Math类】 day09【继承、super、this、抽象类】 day10【接口、多态】 day11【final、权限...

    Java入门基础学习资料day03-04

    day06【类与对象、封装、构造方法】 day07【Scanner类、Random类、ArrayList类】 day08【String类、static关键字、Arrays类、Math类】 day09【继承、super、this、抽象类】 day10【接口、多态】 day11【final、权限...

    basic_day01_v1_pm_all.zip

    4. **类和对象**:理解面向对象编程的基础,包括类的定义,对象的创建,封装,继承和多态的概念。初学者需要学会如何定义属性和方法,以及如何通过对象调用这些方法。 5. **数组**:学习如何声明、初始化和操作数组...

Global site tag (gtag.js) - Google Analytics