Java之类的封装,继承,多态

类的封装

        将对象的状态信息隐藏在对象内部,不允许外部程序直接访问对象内部信息,而是通过该类所提供的方法来实

        现对内部信息的操作和访问。封装是通过设置访问控制符实现的,他们的访问控制如下:


private default portected public 
同一个类中
同一个包中
子类中

全局范围内


    封装的目的

            1.隐藏类的实现细节

            2.让使用者只能通过事先预定的方法来访问数据,从而可以在该方法里加入控制逻辑,限制对Field的不合

               理访问。

            3.可进行数据检查,从而有利于保证对象信息的完整性。

            4.便于修改,提高代码的可维护性。

    封装的设计基本原则

            1.类里的绝大部分Field都应该使用private修饰,只有一些static修饰的,类似全局变量的Field才考虑使用

               public修饰。除此之外,有些函数只是用于铺助实现该类的其他函数,这些函数被称为工具方法,也应

               该使用private修饰。

            2.如果某个类主要用作其他类的父类,该类里包含的大部分方法可能仅希望被其子类重写,而不想被外界

               直接调用,则应该使用protected修饰这些方法。

            3.希望暴露出来给其他类自由调用的方法应该使用public修饰。因此,类的构造器通过使用public修饰,从

               而允许在其他地方创建该类的实例。因此外部类通常都希望被其他类自由使用,所以大部分外部类都使

               用public修饰 

    例子

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public  class  Fruit{
     private  String name;
     private  float   weight;
     private  float   price;
     
     public  Fruit(String name, float  weight){
         setName(name);
         setWeight(weight);
     }
     
     private  void  setName(String name){
         this .name = name;
     }
     
     public  void  setWeight( float  weight){
         this .weight = weight;
    
     
     public  void  setPrice( float  price){
         this .price = price;
     }
     
     public  float  getName(){
         return  name;
     }
     
     public  float  getWeight(){
         return  weight;
     }
     
     public  float  getPrice(){
         return  price;
     }
}

    类的继承

        Java类中只有一个直接父类,没有多继承

    类方法重写

        子类包含与父类同名函数的现象被称为函数重写,也称覆盖。

    Super限定

        super限定用来在子类函数中调用父类被覆盖的实例函数。

    子类构造器调用父类构造器的几个情况

        1.子类构造器执行体的第一行使用super显式调用父类构造器,系统将根据super调用传入的实参列表调用父类

           构造器

        2.子类构造器执行体的第一行代码使用this显式调用本类中重载的构造器,系统将根据this调用里传入的实参列表

           调用本类中的另一个构造器。执行本类中另一个构造器时即会调用父类构造器。

        3.子类构造器执行体中既没有this,也没有super,系统将会执行子类构造器之前,隐式调用父类无参数的构造

           器。

    例子

?
1
2
3
4
5
public  class  Apple  extends  Fruit{
     public  Apple (String name, float  weight){
         super (name,weight);
     }
}

    类的多态

        相同类型的变量,调用同一个方法时呈现出多种不同的行为特征,称之为多态。

        引用变量的两个类型

            编译时类型:由声明该变量时使用的类型决定。

            运行时类型:由实际赋给该变量的对象决定。

        多态的产生

            当编译时类型和运行时类型不一致时,则产生了多态。

        Java中的许多对象(一般都是具有父子类关系的父类对象)在运行时都会出现两种类型:编译时类型和运行时类型,例如:Person person = new Student();这行代码将会生成一个person变量,该变量的编译时类型是Person,运行时类型是Student。

    说明一下编译时类型和运行时类型:

    Java的引用变量有两个类型,一个是编译时类型,一个是运行时类型,编译时类型由声明该变量时使用的类型决定,运行时类型由实际赋给该变量的对象决定。如果编译时类型和运行时类型不一致,会出现所谓的多态。因为子类其实是一种特殊的父类,因此java允许把一个子类对象直接赋值给一个父类引用变量,无须任何类型转换,或者被称为向上转型,由系统自动完成。

    引用变量在编译阶段只能调用其编译时类型所具有的方法,但运行时则执行它运行时类型所具有的方法,因此,编写Java代码时,引用变量只能调用声明该变量所用类里包含的方法。与方法不同的是,对象的属性则不具备多态性。通过引用变量来访问其包含的实例属性时,系统总是试图访问它编译时类所定义的属性,而不是它运行时所定义的属性。

?
1
2
3
4
5
public  class  Test {
     public  static  void  main(String[] args){
           Fruit fruit =  new  Apple();     // 多态产生 其中Fruit为编译时类型 而new Apple()为运行时类型
     }
}

        从设计上看面向对象的三大特性

            1.继承是为了对物的信息进行抽象

            2.多态是为了对物的行为进行抽象

            3.封装是为了对物与外界交流进行抽象

  • 2
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值