黑马程序员_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
    }
}

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

黑马程序员—IOS基础之OC—类的三大特性封装、继承、多态

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

黑马程序员--OC的三大特性 封装 继承 多态

-----------android培训、java培训、java学习型技术博客、期待与您交流!------------  面向对象的三大特性 1.封装2.组合3.多态 封装: 为什么要...

黑马程序员——OC语言基础:面向对象三大特性,封装、继承、多态

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ------- 一、封装性 1.set方法 #import @interface Student :...
  • Big_Zzq
  • Big_Zzq
  • 2015年04月27日 18:51
  • 384

黑马程序员 - OC语言 - 面向对象三大特性,封装、继承、多态

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ——-一、封装 1. set方法(提供一个方法,让外界设置成员变量的值,可以在方法里面对参数进行过滤) (1)...

黑马程序员_iOS开发之OC之面向对象之三大特性封装、继承和多态

一、封装 1、封装的

黑马程序员-OC之面向对象的三大特性:封装、继承和多态

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ------- 1.  继承 1>  继承的优点: 1、代码的可重用性 2、父类的属性和方法可用于子类 3、设...

黑马程序员-④面向对象三大特性封装、继承、多态

de

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

1. 封装(成员变量封装)   优点:外界无法随意修改类中成员值或屏蔽类中成员变量,提高了程序安全性。   在安全性前提下,外界访问类对象中成员值可通过以下方法:  1.1 set方法(可读可写...

黑马程序员——OC语言学习——OC面向对象的三大特性:封装、继承、多态,OC字符串——NSString

一、   封装 在之前我们操作对象里的成员变量需要,需要在定义类时,在类的声明里加上 @public 如: @interface Student : NSObject { @public ...
  • dimost
  • dimost
  • 2015年03月12日 00:04
  • 263

黑马程序员---OC面向对象三大特性(封装、继承、多态)

———Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ———
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:黑马程序员_Java三大特性(封装 继承 多态)
举报原因:
原因补充:

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