JavaSE（二）之继承、封装、多态详解编程语言

学习完类与对象终于认识到什么是类，什么是对象了。接下来要看的就是java的三大特征：继承、封装、多态。

一、封装（数据的隐藏）

在定义一个对象的特性的时候，有必要决定这些特性的可见性，即哪些特性对外部是可见的，哪些特性用于表示内部状态。
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

1.1、封装的步骤 

    1）.使用private 修饰需要封装的成员变量。
    2.）提供一个公开的方法设置或者访问私有的属性
  设置 通过set方法，命名格式：  set属性名（）;  属性的首字母要大写
  访问 通过get方法，命名格式：  get属性名（）;  属性的首字母要大写

1.2、举例 

   //对象不仅能再类中方法,还能在类的外部 直接 访问
       public class Student{
         public String name;
         public void println(){
           System.out.println(this.name);
       }
       }
       public class Test{
       public static void main(String[] args){
         Student s = new Student();
         s.name = tom
         }
     }
 
   在类中一般不会把数据直接暴露在外部的,而使用private(私有)关键字把数据隐藏起来
   例如:
     public class Student{
       private String name;
       }

       public class Test{
       public static void main(String[] args){
         Student s = new Student();
           //编译报错,在类的外部不能直接访问类中的私有成员
           s.name = tom
       }
     }

   如果在类的外部需要访问这些私有属性,那么可以在类中提供对于的get和set方法,以便让用户在类的外部可以间接的访问到私有属性
   例如:
     //set负责给属性赋值
     //get负责返回属性的值
     public class Student{
         private String name;
       public void setName(String name){
           this.name = name;
       }
         public String getName(){
           return this.name;
         }
       }

       public class Test{
       public static void main(String[] args){
         Student s = new Student();
           s.setName( tom );
           System.out.println(s.getName());
       }
       }

1.3、封装的作用

1）框架

2）工具类

1.4、封装的意义

1)隐藏代码的实现细节
   2)统一用户的调用接口
   3)提高系统的可维护性

二、方法的重载

类中有多个方法,有着相同的方法名,但是方法的参数各不相同,这种情况被称为方法的重载。
方法的重载可以提供方法调用的灵活性。

     例如:System.out.println()中的println方法,为什么可以把不同类型的参数传给这个方法?
     例如:
       public class Test{
         public void test(String str){

         }
         public void test(int a){
         }
       }

   方法重载必须满足一下条件:
     1)方法名相同
     2)参数列表不同(参数的类型、个数、顺序的不同)
       public void test(Strig str){}
       public void test(int a){}

       public void test(Strig str,double d){}
       public void test(Strig str){}

       public void test(Strig str,double d){}
       public void test(double d,Strig str){}
     3)方法的返回值可以不同，也可以相同。
   注:在java中,判断一个类中的俩个方法是否相同,主要参考俩个方面:方法名字和参数列表

1)继承是类和类之间的一种关系
     除此之外,类和类之间的关系还有依赖、组合、聚合等。

      2)继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。
     子类继承父类,使用关键字extends来表示
     例如:
     public class student extends Person{
       
     }

   3)子类和父类之间,从意义上讲应该具有 is a 的关系.
     例如:
       student is a person
       dog is a animal

   4)类和类之间的继承是单继承
     一个子类只能 直接 继承一个父类,就像是一个人只能有一个亲生父亲
     一个父类可以被多子类继承,就像一个父亲可以有多个孩子

     注:java中接口和接口之间,有可以继承,并且是多继承。

   5)父类中的属性和方法可以被子类继承
     子类中继承了父类中的属性和方法后,在子类中能不能直接使用这些属性和方法,是和这些属性和方法原有的修饰符(public protected default private)相关的。
       例如:
       父类中的属性和方法使用public修饰,在子类中继承后 可以直接 使用
       父类中的属性和方法使用private修饰,在子类中继承后 不可以直接 使用
     注:具体细则在修饰符部分详细说明
     
     父类中的构造器是不能被子类继承的,但是子类的构造器中,会隐式的调用父类中的无参构造器(默认使用super关键字)。
     注:具体细节在super关键字部分详细说明

   6)Object类
     java中的每一个类都是 直接 或者 间接 的继承了Object类.所以每一个对象都和Object类有 is a 的关系。从API文档中,可以看到任何一个类最上层的父类都是Object。(Object类本身除外)
       AnyClass is a Object
     
     例如:
       System.out.println(任何对象 instanceof Object);
       //输出结果:true
     注:任何对象也包含数组对象

     例如:
       //编译后,Person类会默认继承Object
       public class Person{}

       //Student是间接的继承了Object
       public class Student extends Person{}
       

     在Object类中,提供了一些方法被子类继承,那么就意味着,在java中,任何一个对象都可以调用这些被继承过来的方法。(因为Object是所以类的父类)
       例如:toString方法、equals方法、getClass方法等
     
     注:Object类中的每一个方法之后都会使用到.

四、super关键字

子类继承父类之后,在子类中可以使用this来表示访问或调用子类中的属性或方法,使用super就表示访问或调用父类中的属性和方法。

4.1、super的使用

1)访问父类中的属性
       例如:
       public class Person{
         protected String name = zs
     }
       public class Student extends Person{
       private String name = lisi
       public void tes(String name)t{
           System.out.println(name);
           System.out.println(this.name);
           System.out.println(super.name);
       }
       }

2)调用父类中的方法
     例如:
     public class Person{
       public void print(){
           System.out.println( Person );
       }
     }
     public class Student extends Person{
       public void print(){
         System.out.println( Student );
       }
       public void test(){
           print();
           this.print();
           super.print();
         }
       }

3)调用父类中的构造器
     例如:
       public class Person{
       
       }
     public class Student extends Person{
         //编译通过,子类构造器中会隐式的调用父类的无参构造器
         //super();
         public Student(){
         }
       }

     例如:
     public class Person{
       protected String name;
       public Person(String name){
           this.name = name;
       }
     }
     public class Student extends Person{
       //编译报错,子类构造器中会隐式的调用父类的无参构造器,但是父类中没有无参构造器
         //super();
       public Student(){

       }
     }

     例如:
     public class Person{
         protected String name;
         public Person(String name){ 

      this.name = name;
       }
       }
       public class Student extends Person{
       //编译通过,子类构造器中显式的调用父类的有参构造器
       public Student(){
         super( tom );
         }
       } 
     注:不管是显式还是隐式的父类的构造器,super语句一定要出现在子类构造器中第一行代码。所以this和super不可能同时使用其调用构造器的功能,因为它们都要出现在第一行代码位置。
 
     例如:
       public class Person{
       protected String name;
         public Person(String name){
         this.name = name;
         }
     }
     public class Student extends Person{
         //编译报错,super调用构造器的语句不是第一行代码
       public Student(){
         System.out.println( Student );
           super( tom );
         }
       }
 
       例如:
       public class Person{
         protected String name;
         public Person(String name){
           this.name = name;
         }
     }
     //编译通过
     public class Student extends Person{
       private int age;
         public Student(){
           this(20);
         }
         public Student(int age){
           super( tom );
         this.age = age;
       }
     }

4.2、super使用的注意的地方

  1）用super调用父类构造方法，必须是构造方法中的第一个语句。
  2）super只能出现在子类的方法或者构造方法中。
    3）super 和 this 不能够同时调用构造方法。（因为this也是在构造方法的第一个语句）

  4.3、super 和 this 的区别

  1）代表的事物不一样:
  this：代表所属方法的调用者对象。
    super：代表父类对象的引用空间。
    2）使用前提不一致：
    this：在非继承的条件下也可以使用。
  super：只能在继承的条件下才能使用。
    3）调用构造方法：
    this：调用本类的构造方法。
    super：调用的父类的构造方法

五、方法重写（方法覆盖）

1)方法重写只存在于子类和父类(包括直接父类和间接父类)之间。在同一个类中方法只能被重载，不能被重写.

    2)静态方法不能重写
  a. 父类的静态方法不能被子类重写为非静态方法 //编译出错
  b. 父类的非静态方法不能被子类重写为静态方法；//编译出错
  c. 子类可以定义与父类的静态方法同名的静态方法(但是这个不是覆盖)
     例如:
        A类继承B类 A和B中都一个相同的静态方法test
          B a = new A();
          a.test();//调用到的是B类中的静态方法test

          A a = new A();
          a.test();//调用到的是A类中的静态方法test

      可以看出静态方法的调用只和变量声明的类型相关
        这个和非静态方法的重写之后的效果完全不同

  3)私有方法不能被子类重写
     子类继承父类后,是不能直接访问父类中的私有方法的,那么就更谈不上重写了。
   
     例如:
     public class Person{
       private void run(){}
     }
     //编译通过,但这不是重写,只是俩个类中分别有自己的私有方法
     public class Student extends Person{
       private void run(){}
     }

  4)重写的语法
     1.方法名必须相同
     2.参数列表必须相同
     3.访问控制修饰符可以被扩大,但是不能被缩小
       public protected default private
     4.抛出异常类型的范围可以被缩小,但是不能被扩大
       ClassNotFoundException Exception  
     5.返回类型可以相同,也可以不同,如果不同的话,子类重写后的方法返回类型必须是父类方法返回类型的子类型
       例如:父类方法的返回类型是Person,子类重写后的返回类可以是Person也可以是Person的子类型

     注:一般情况下,重写的方法会和父类中的方法的声明完全保持一致,只有方法的实现不同。(也就是大括号中代码不一样)

     例如:
     public class Person{
       public void run(){}

       protected Object test()throws Exception{
         return null;
       }
     }
     //编译通过,子类继承父类,重写了run和test方法.
     public class Student extends Person{
       public void run(){}

       public String test(){
         return
       }
     }
     
  5)为什么要重写
     子类继承父类,继承了父类中的方法,但是父类中的方法并不一定能满足子类中的功能需要,所以子类中需要把方法进行重写。

6）总结：

方法重写的时候，必须存在继承关系。

  方法重写的时候，方法名和形式参数 必须跟父类是一致的。

    方法重写的时候，子类的权限修饰符必须要大于或者等于父类的权限修饰符。( private protected public，friendly public )

    方法重写的时候，子类的返回值类型必须小于或者等于父类的返回值类型。(  子类 父类 )  数据类型没有明确的上下级关系

    方法重写的时候，子类的异常类型要小于或者等于父类的异常类型。

允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。
相同类域的不同对象,调用相同的方法,执行结果是不同的

   1)一个对象的实际类型是确定的
     例如: new Student(); new Person();等

   2)可以指向对象的引用的类型有很多
     一个对象的实现类型虽然是确定的,但是这个对象所属的类型可能有很多种。
     例如: Student继承了Person类
     Student s1 = new Student();
     Person s2  = new Student();
     Object s3  = new Student();

     因为Person和Object都是Student的父类型

     注:一个对象的实际类型是确定,但是可以指向这个对象的引用的类型,却是可以是这对象实际类型的任意父类型。
     
   3)一个父类引用可以指向它的任何一个子类对象
     例如:
     Object o = new AnyClass();
     Person p = null;
     p = new Student();
     p = new Teacher();
     p = new Person();

   4)多态中的方法调用
     例如:
     public class Person{
       public void run(){}
     }
     public class Student extends Person{

     }
     //调用到的run方法,是Student从Person继承过来的run方法
     main:
       Person p = new Student();
       p.run();

     例如:
     public class Person{
       public void run(){}
     }
     public class Student extends Person{
       public void run(){
         //重写run方法
       }
     }
     //调用到的run方法,是Student中重写的run方法
     main:
       Person p = new Student();
       p.run();
 
     注:子类继承父类,调用a方法,如果a方法在子类中没有重写,那么就是调用的是子类继承父类的a方法,如果重写了,那么调用的就是重写之后的方法。
 
   5)子类中独有方法的调用
     例如:
     public class Person{
       public void run(){}
     }
     public class Student extends Person{
       public void test(){
       }
     }
     main:
       Person p = new Student();
       //调用到继承的run方法
       p.run();
       
       //编译报错,因为编译器检查变量p的类型是Person,但是在Person类中并没有发现test方法,所以编译报错.
       p.test();
     
     注:一个变量x,调用一个方法test,编译器是否能让其编译通过,主要是看声明变量x的类型中有没有定义test方法,如果有则编译通过,如果没有则编译报错.而不是看x所指向的对象中有没有test方法.

原理：编译看左边，运行不一定看右边。
        编译看左边的意思：java 编译器在编译的时候会检测引用类型中含有指定的成员，如果没有就会报错。子类的成员是特有的，父类的没有的，所以他是找不到的。

   6)子类引用和父类引用指向对象的区别
     Student s = new Student();
     Person p = new Student();
     
     变量s能调用的方法是Student中有的方法(包括继承过来的),变量p能调用的方法是Person中有的方法(包括继承过来的)。

     但是变量p是父类型的,p不仅可以指向Student对象,还可以指向Teacher类型对象等,但是变量s只能指向Studnet类型对象,及Student子类型对象。变量p能指向对象的范围是比变量s大的。
   
     Object类型的变量o,能指向所有对象,它的范围最大,但是使用变量o能调用到的方法也是最少的,只能调用到Object中的声明的方法,因为变量o声明的类型就是Object.
   
     注:java中的方法调用,是运行时动态和对象绑定的,不到运行的时候,是不知道到底哪个方法被调用的。

   7)重写、重载和多态的关系
     重载是编译时多态
       调用重载的方法,在编译期间就要确定调用的方法是谁,如果不能确定则编译报错
     重写是运行时多态
       调用重写的方法,在运行期间才能确定这个方法到底是哪个对象中的。这个取决于调用方法的引用,在运行期间所指向的对象是谁,这个引用指向哪个对象那么调用的就是哪个对象中的方法。(java中的方法调用,是运行时动态和对象绑定的)
   
   8)多态的注意事项

多态情况下，父类 和 子类存在同名的成员变量，无论是静态的还是非静态的变量，默认访问的是父类中的成员变量。
  多态情况下，父类 和 子类存在同名的非静态方法，访问的是子类的非静态方法。
  多态情况下，父类 和子类存在同名的静态方法，访问的是父类的静态方法。
  多态情况下，不能访问子类特有的属性、方法。
  多态满足的条件：必须要有继承关系。
  多态情况下，子类 和 父类如果存在同名的成员，访问的都是父类，除了同名的非静态变量访问的才是子类。
9）多态存在的条件

1)有继承关系
2)子类重写父类方法
3)父类引用指向子类对象
补充一下第二点，既然多态存在必须要有“子类重写父类方法”这一条件，那么以下三种类型的方法是没有办法表现出多态特性的（因为不能被重写）：

1)static方法，因为被static修饰的方法是属于类的，而不是属于实例的
2)final方法，因为被final修饰的方法无法被子类重写
3)private方法和protected方法，前者是因为被private修饰的方法对子类不可见，后者是因为尽管被protected修饰的方法可以被子类见到，也可以被子类重写，但是它是无法被外部所引用的，一个不能被外部引用的方法，怎么能谈多态呢

七、instanceof和类型转换 7.1、instanceof

public class Person{
     public void run(){}
   }
   public class Student extends Person{
   }
   public class Teacher extends Person{
   }
   
   例如:
     main:
       Object o = new Student();
       System.out.println(o instanceof Student);//true
       System.out.println(o instanceof Person);//true
       System.out.println(o instanceof Object);//true
       System.out.println(o instanceof Teacher);//false
       System.out.println(o instanceof String);//false
       
     
       Person o = new Student();
       System.out.println(o instanceof Student);//true
       System.out.println(o instanceof Person);//true
       System.out.println(o instanceof Object);//true
       System.out.println(o instanceof Teacher);//false
       //编译报错
       System.out.println(o instanceof String);   
       
       Student o = new Student();
       System.out.println(o instanceof Student);//true
       System.out.println(o instanceof Person);//true
       System.out.println(o instanceof Object);//true
       //编译报错
       System.out.println(o instanceof Teacher);
       //编译报错
       System.out.println(o instanceof String);

       注1:
         System.out.println(x instanceof Y);
         该代码能否编译通过,主要是看声明变量x的类型和Y是否存在子父类的关系.有 子父类关 系就编译通过,没有子父类关系就是编译报错.
         之后学习到的接口类型和这个是有点区别的。
       
       注2:
         System.out.println(x instanceof Y);
         输出结果是true还是false,主要是看变量x所指向的对象实际类型是不是Y类型的 子类型 .
   
   例如:
     main:
       Object o = new Person();
       System.out.println(o instanceof Student);//false
       System.out.println(o instanceof Person);//true
       System.out.println(o instanceof Object);//true
       System.out.println(o instanceof Teacher);//false
       System.out.println(o instanceof String);//false

7.2、类型转换 

   public class Person{
       public void run(){}
     }
     public class Student extends Person{
       public void go(){}
     }
     public class Teacher extends Person{
     }

     1)为什么要类型转换
       //编译报错,因为p声明的类型Person中没有go方法
       Person p = new Student();
       p.go();

       //需要把变量p的类型进行转换
       Person  p = new Student();
       Student s = (Student)p;
       s.go();
       或者
       //注意这种形式前面必须要俩个小括号
       ((Student)p).go();       
     
     2)类型转换中的问题
       //编译通过 运行没问题
       Object o = new Student();
       Person p = (Person)o;

 
       //编译通过 运行没问题
       Object o = new Student();
       Student s = (Student)o;
     
       //编译通过,运行报错
       Object o = new Teacher();
       Student s = (Student)o;

   
       即:
         X x = (X)o;
         运行是否报错,主要是变量o所指向的对象实现类型,是不是X类型的子类型,如果不是则运行就会报错。

 

 

12422.html

cgojava