黑马程序员_Java三大特性(封装 继承 多态)

原创 2015年11月19日 14:05:54

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------


1 封装

1.1 封装性的概念 

    1、封装性是面向对象思想的三大特性之一
    2、是指隐藏对象的属性和实现细节,仅对外提供公共的访问方式 
    3、封装有:
      属性的封装
      方法的封装(方法本来就是一种封装体)
      类的封装(属性和方法的集体封装)
      组件的封装
      模块化封装
      系统级封装
    4、封装原则:
                    将不需要对外提供的内容都隐藏起来             
                       把属性都隐藏,提供公共方法对其访问
    5、函数也是封装的一种体现,函数是java中最小的封装 体

1.2 封装的好处

    1、模块化,便于使用
    2、信息隐藏,将变化隔离
    3、代码重用
    4、插件化易于调试
    5、提高安全性

1.3 属性的封装

    1、把属性定义为私有的(只能在本类中直接访问)
    2、为属性提供get/set方法(通过这两个方法间接访问类中的属性)
    将属性使用private封装后,类以外即使建立了对象也不能直接访问了 。但是人应该有年龄,就需要在person类中提供对应访问age的方式(set()和get()) 
    就可以在访问方式中加入逻辑判断等语句 对访问的数据进行操作,提高代码的健壮性

public class Object_Encapsulation {
    public static void main(String[] args) {
        Person p=new Person();
        p.setAge(20);
        //p.speak();
    }
}
class Person{
    private int age;
    //对外提供访问方式
    public void setAge(int age){
        if (age>0 && age<130){
           this.age=age;
           speak();
        }
        else
            System.out.println("age feifa");

    }

    public int getAge(){
        return age;
    }
//一个成员变量的访问方式一般会对应两种方式一个是set (没有返回值)一个时get(返回值时int)

    void speak(){
        System.out.println("age="+age);
    }
}
public class SixtyEight_SixtyNine_Seventy {
    public static void main(String[] args) {
        Person p = new Person();
        p.name = "baobao";
        p.age = 20;
        p.say();
        
        
        //----------------------------------
        
        Personn p1 = new Personn();
        p1.setName("包包");
        p1.setAge(22);
        p1.say();
        
    }
}
class Person{
    String name;//如果没有将类的属性进行封装,外部类可以随意修改类的属性
    int age;
    void say(){
        System.out.println("我是:"+name+",今年"+age+"岁");
    }
}


class Personn{
    private String name;//将类的属性进行封装,外部类不可以随意修改类的属性
    private int age;
    void say(){
        System.out.println("我是:"+getName()+",今年"+getAge()+"岁");
    }
    
    //将类的属性进行封装后,需要提供一个设置属性值和获取属性值得方法(对外提供接口)   对应的是set 和 get
    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;
    }
}

2 继承

2.1 继承的基本概念:

    1、继承是面向对象的三大特性之一
     2、被继承的类称为父类(超类),继承父类的类称为子类(派生类)
     3、继承是指一个对象直接使用另一个对象的属性和方法(继承之后才能使用)
     4、通过继承可以实现代码重用

2.2 使用继承的要求

    1、将每个类的共性提取出来单独放在一个类中来描述
     2、然后让这个类与其他每个类之间有点关系这样就可以了
     3、注意:千万不要为了获取其他类的功能,简化代码而继承
     4、必须是类与类之间有所属关系才可以继承
     5、例如:将学生和工人的共性(共同属性,共同方法)描述提取出来。单独进行描述。只要让学生和工人与单独描述的这个类有关系,就可以了。


2.3 继承的好处

    1、提高了代码的复用性
    2、让类与类之间产生了关系,有了这个关系,才有了多态的特性

2.4 继承的语法

public class extendsDemo {
    public static void main(String[] args) {
        HomeChicken c1 = new HomeChicken();
        c1.desc();
    }
}

//父类
class Chicken{
    String name;

    public Chicken(){}
    
    public Chicken(String name) {
        super();
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }


    public void desc(){
        System.out.println("我是一只战斗鸡");
    }
}

//子类
class HomeChicken extends Chicken{
    
}

//子类
class Pheasant extends Chicken{
    
}

2.5 代码实例

public class ExtendsDemo1 {
    public static void main(String[] args) {

    }
}
class Person{
    String name;
    int age;
}
class Student extends Person{
    void study(){
        System.out.println("good study");
    }
}
class Worker extends Person{
    void work(){
        System.out.println("good work");
    }
}

2.6 继承中使用时需要注意的

     1、java不支持多继承:java语言中只支持单继承不支持多继承(一个类继承了另一个类就不能在继承其他类了)
                 因为多继承容易带来安全隐患 当多个父类中定义了相同功能,但功能内容不同时,子类对象不确定要运行哪一个。
                 但是java保留了这种机制,并用另一种体现形式来完成表现叫做多实现
     2、java支持多层继承:java语言中支持多层继承 ,就是一个继承体系
     3、继承只能继承非私有的属性和方法
     4、如何使用一个继承体系中的功能:想要使用体系,先查阅体系父类的描述,因为父类中定义的是该体系中的共性功能通过了解共性功能,就可以知道该体系的基本功能
  5、那么具体调用时,要创建最子类的对象,  为什么呢?
        (1)是因为有可能父类不能创建对象(抽象类)
         (2)是创建子类对象可以使用更多的功能,包括基本的也包括特有的
        简单一句话就是:查阅父类功能,创建子类对象使用功能
     6、构造方法不能被继承
     7、那么在继承中不能继承父类的私有成员,怎么办呢
        (1)访问修饰符:public(公有) private(私有) default(默认(本包中的所有类都可以访问)) protected(保护型(专门继承用的,子类的对象都能狗使用被该修饰符修饰的属性或者方法))
        (2)非私有:public(公有) default(默认) protected(保护型)

public class oneHundredAndNineteenFive {

    public static void main(String[] args) {
        HomeDog d1 = new HomeDog("小白");
        d1.name = "小黑";
        d1.desc();
        
        /*下面这个类不是Dog的子类,所以创建了对象也不能够使用Dog里的共性属性和方法
        fuck f = new fuck();
        f.name = "西安";
        f.desc();
        */
    }
}

//父类
class Dog{
    protected String name;//对于父类的共性属性可以使用该修饰符,这样子类是可以继承到的

    public Dog(){}
    
    public Dog(String name) {
        super();
        this.name = name;
    }

    protected void desc(){
        System.out.println("我是一只战斗鸡"+name);
    }
}

//子类
class HomeDog extends Dog{
    public HomeDog(String name) {
        this.name = name;
    }
}

//子类
class PheasantDog extends Dog{
    
}
class fuck{
    
}

3 多态

3.1 多态性的概念

     1、多态性是面向对象的三大特性之一
     2、可以理解为事物存在多种体现形态。比如动物:猫,狗

3.2 多态性的两种情况

     1、方法的重载和重写
     2、对象的多态性


3.3 对象的多态性

     1、多态的体现
     父类的引用指向了自己的子类对象
     父类的引用也可以接收自己的子类对象
     2、多态的前提
     必须是类与类之间有关系,要么继承,要么实现。
     通常还有一个前提就是存在覆盖

3.4 多态的好处和弊端

     多态的好处:
     多态的出现大大地提高了扩展性,前期的代码可以使用后期的代码
     多态的弊端:
       提高了扩展性,但是只能使用父类的引用访问zi类中的共性成员(不能访问子类的特有的成员)


abstract class Animal{
    public abstract void eat();
}

class Cat extends Animal{
    public void eat(){
        System.out.println("吃鱼");
    }
    public void CatchMouse(){
        System.out.println("抓老鼠");
    }
}

class Dog extends Animal{
    public void eat(){
        System.out.println("吃骨头");
    }
    public void kanjia(){
        System.out.println("看家");
    }
}

class Pig extends Animal{
    public void eat(){
        System.out.println("饲料");
    }
    public void gongDi(){
        System.out.println("拱地");
    }
}



class DuoTaiDemo {
    public static void main(String[] args) {
        Animal a = new Cat();//类型提升,向上转型
        //function(new Cat());

        //如果想要调用猫的特有方法时,如何操作
        //强制将父类的引用,转成子类类型,向下转型
        //Cat c = new Cat();//错误 又new了一只新猫
        //Cat c = (Cat)a;//强制将父类的引用转成子类类型,强制类型转换,将动物类型转换成猫

        //c.catchMouse();
        /*
        Animal a = new Animal();
        Cat c = (Cat)a;
        不能将父类对象转换成子类 类型,自始自终都是类型在变化
        能转换的是父类的引用指向了子类对象是,
        */
    }

    public static void function(Animal c){//相当于Animal c = new Cat();父类的引用也可以接收自己的子类对象
        c.eat();
        //instanceof用于判断对象的具体类型
        if (c instanceof Cat){
            Cat a = (Cat)c;
            a.catchMouse();
        }
        else if (c instanceof Dog){
            Dog a = (Dog)c;
            c.kanjia();
        }
        //通常情况下我们不会这么判断,因为扩展性很差。如果加个子类就要再判断一次.有两种情况是用这种方法来判断的:子类是有限的,比如人要么男人要么女人
    }
}

3.5 在多态中成员变量的特点:

     在编译时期,参阅引用型变量所属的类中是否有调用的成员变量,如果有编译通过,如果没有编译失败
     在运行时期,参阅引用型变量所属的类中是否有调用的成员变量,并运行该所属类中的成员变量
     简单总结就是:无论编译和运行,都参考左边

class Fu{
    int num = 3;//如果父类没有该num,会编译失败。
}

class Zi extends Fu{
    int num = 4;
}

class DuoTaiDemo4 {
    public static void main(String[] args) {
        Fu f = new Zi();
        System.out.println(f.num);//结果是3
    }
}

3.6 在多态中成员函数(非静态)的特点:

     在编译时期,参阅引用型变量所属的类中是否有调用的方法,如果有编译通过,如果没有编译失败
     在运行时期,参阅对像所属的类中是否有调用的方法
     简单总结就是:成员函数在多态调用时,编译看左边,运行看右边

class Fu{
    void show(){
        System.out.pritnln("Fu show");
    }
}

class Zi extends Fu{
    void show(){
        System.out.pritnln("Zi show");
    }
}

class DuoTaiDemo4 {
    public static void main(String[] args) {
        Fu f = new Zi();
        f.show();//结果是Zi show
    }
}

3.7 在多态中,静态成员函数的特点:

     在编译时期,参阅引用型变量所属的类中是否有调用的静态方法,如果有编译通过,如果没有编译失败
     在运行时期,参阅引用型变量所属的类中是否有调用的静态方法
     简单总结就是:无论编译和运行都参考左边

class Fu{
    static void show(){
        System.out.pritnln("Fu show");
    }
}

class Zi extends Fu{
    static void show(){
        System.out.pritnln("Zi show");
    }
}

class DuoTaiDemo4 {
    public static void main(String[] args) {
        Fu f = new Zi();
        f.show();//结果是Fu show
    }
}

版权声明:本文为博主原创文章,未经博主允许不得转载。

面向对象编程三大特性------封装、继承、多态

本文是对面向对象编程三大特性(封装、继承、多态)的一个学习总结。 封装隐藏了类的内部实现机制,可以在不影响使用的情况下改变类的内部结构,同时也保护了数据。对外界而已它的内部细节是隐藏的,暴露给外界的只...
  • jianyuerensheng
  • jianyuerensheng
  • 2016年06月07日 11:41
  • 8690

OC学习篇之---类的三大特性(封装,继承,多态)

之前的一片文章介绍了OC中类的初始化方法和点语法的使用:http://blog.csdn.net/jiangwei0910410003/article/details/41683873,今天来继续学习...
  • jiangwei0910410003
  • jiangwei0910410003
  • 2014年12月04日 22:20
  • 31282

【面试题】Java三大特性封装继承多态总结

本文内容总结于多篇博客,参考到的地方在文中都会一一列出 http://www.cnblogs.com/ibalintha/p/3897821.html 1.封装 封装...
  • zjkC050818
  • zjkC050818
  • 2017年10月18日 22:15
  • 618

c++面向对象三大特征封装、继承和多态知识总结

面向对象三大特征:封装,继承,多态; 一、封装:该公开的就公开话,该私有的就隐藏掉,主要是由public,private实现;作用是便于分工和分模块,防止不必要的扩展; 二、继承:就是一种传承,可以把...
  • uestclr
  • uestclr
  • 2016年06月05日 18:23
  • 2879

java提高篇(二)-----理解java的三大特性之继承

在《Think in java》中有这样一句话:复用代码是Java众多引人注目的功能之一。但要想成为极具革命性的语言,仅仅能够复制代码并对加以改变是不够的,它还必须能够做更多的事情。在这句话中最引人注...
  • chenssy
  • chenssy
  • 2013年10月16日 19:37
  • 20554

java提高篇(三)-----理解java的三大特性之多态

面向对象编程有三大特性:封装、继承、多态。        封装隐藏了类的内部实现机制,可以在不影响使用的情况下改变类的内部结构,同时也保护了数据。对外界而已它的内部细节是隐藏的,暴露给外界的只是它的访...
  • chenssy
  • chenssy
  • 2013年10月16日 19:44
  • 57522

面向对象三要素:封装继承多态的阐述及示例

类、封装、继承、多态概念以及实例
  • u010402786
  • u010402786
  • 2016年05月17日 21:03
  • 1165

Java-面向对象编程-三大特性之多态

我们前面已经介绍了面向对象编程的三大特性之二,今天就介绍最后一个特性-多态。 什么叫多态?从字面上理解就是多种形态,即对同一个客体,可以有多种不同的形式。就好像糖一样,有多种口味,你想吃什么口味的就...
  • dengminghli
  • dengminghli
  • 2017年02月01日 18:14
  • 3422

java 面向对象三大特性(封装,继承,多态)以及抽象、接口的介绍

java 面向对象三大特性(封装,继承,多态)以及抽象、接口的介绍,this,super,构造方法的使用介绍...
  • qq_22118507
  • qq_22118507
  • 2016年05月16日 09:45
  • 7867

java面向对象的四大特性-多态,继承,抽象,封装

1.多态 面向对象的四大特性:封装、继承、多态、抽象。从一定角度来看,封装和继承几乎都是为多态而准备的。是最重要的知识点。多态的定义:指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对...
  • basycia
  • basycia
  • 2016年07月07日 12:54
  • 4146
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:黑马程序员_Java三大特性(封装 继承 多态)
举报原因:
原因补充:

(最多只允许输入30个字)