学习完类与对象终于认识到什么是类,什么是对象了。接下来要看的就是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类型的子类型,如果不是则运行就会报错。

  

  

JavaSE(二)之继承、封装、多态的更多相关文章

  1. OOP面向对象 三大特征 继承封装多态

    OOP面向对象 ----三大特征 继承封装多态 面向对象(Object Oriented,OO)是软件开发方法.面向对象的概念和应用已超越了程序设计和软件开发,扩展到如数据库系统.交互式界面.应用结构 ...

  2. JavaScript基础--面向对象三大特性(八):继承封装多态

    一.构造函数基本用法:function 类名(参数列表){ 属性=参数值} function Person(name,age){ this.name = name; this.age = age; } ...

  3. JavaScript 继承 封装 多态实现及原理详解

    面向对象的三大特性 封装 所谓封装,也就是把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏.封装是面向对象的特征之一,是对象和类概念的主要特性. ...

  4. C++内存中的封装、继承、多态(下)

    上篇讲述了内存中的封装模型,下篇我们讲述一下继承和多态. 二.继承与多态情况下的内存布局 由于继承下的内存布局以及构造过程很多书籍都讲得比较详细,所以这里不细讲.重点讲多态. 继承有以下这几种情况: ...

  5. JavaSE基础知识(5)—面向对象(5.4面向对象三大特征:封装、继承、多态)

    面向对象编程具有三大特征: 封装 继承 多态 一.封装 1.好处 狭义的封装:也就是属性的封装,避免了任意赋值的危险,提高了数据的安全性! ①隐藏一个类中不需要对外提供的实现细节 ②使用者只能通过实现 ...

  6. JavaSE学习总结(五)——封装,继承,多态很简单

    java面向对象的三大特性是:封装.继承与多态,是面向对象编程的核心. 一.封装 简单说封装就是将同一类事物的特性与功能包装在一起,对外暴露调用的接口. 封装:封装也称信息隐藏,是指利用抽象数据类型把 ...

  7. python基础之面向对象(二)(封装、继承、多态)

    一.封装 (1)封装是面向对象的一大特点 (2)面向对象编程的第一步--将属性和方法封装到一个抽象的类当中 (3)外界使用类创建对象,然后让对象调用方法 (4)对象方法的细节都被封装在类的内部 1.案 ...

  8. OC的封装、继承与多态

    面向对象有三大特征:封装.继承和多态. 一.封装 封装是将对象的状态信息隐藏在对象内部,不允许外部程序直接访问对象内部信息,而是通过该类所提供的方法来实现对内部信息的操作和访问.简而言之,信息隐藏,隐 ...

  9. 2、C#面向对象:封装、继承、多态、String、集合、文件(上)

    面向对象封装 一.面向对象概念 面向过程:面向的是完成一件事情的过程,强调的是完成这件事情的动作. 面向对象:找个对象帮你完成这件事情. 二.面向对象封装 把方法进行封装,隐藏实现细节,外部直接调用. ...

  10. Java 三大特性——封装、继承、多态

    一.封装 封装,实际就是把属于同一类事物的共性(包括属性与方法)归到一个类中,以方便使用. 概念:在面向对象程式设计方法中,封装(英语:Encapsulation)是指,一种将抽象性函式接口的实作细节 ...

随机推荐

  1. js获取上传图片真实的尺寸大小和存储大小

    https://blog.csdn.net/u014236259/article/details/52885591 ****************************************** ...

  2. JAVA实现MD5加密算法(使用MessageDigest)

    http://blog.csdn.net/ymc0329/article/details/6738711 *********************************************** ...

  3. lsblk命令

    lsblk命令用于列出所有可用块设备的信息,而且还能显示他们之间的依赖关系,但是它不会列出RAM盘的信息.块设备有硬盘,闪存盘,cd-ROM等等.lsblk命令包含在util-linux-ng包中,现 ...

  4. Android之Activity切换

    ●假如有Activity01和Activity02,从Activity01切换到Activity02并传递参数. Activity01中: button.setOnClickListener(new  ...

  5. C#学习笔记(3)——操作sqlserver数据库增删改查

    说明(2017-5-25 16:29:35): 1. VS2010,视图->服务器资源管理器->数据连接->右键添加连接->服务器名(本机可以用点)->选择数据库-> ...

  6. 7. 集成学习(Ensemble Learning)Stacking

    1. 集成学习(Ensemble Learning)原理 2. 集成学习(Ensemble Learning)Bagging 3. 集成学习(Ensemble Learning)随机森林(Random ...

  7. ORA-12541:TNS:无监听程序 配置Oracle Myeclipse无法连接上 花费一天时间解决掉的

    背景:自己机子做oracle服务器,其他机子可以ping得通我的机子,但是jdbc就是连不上,后来用plsql连出现无监听程序.... 我昨天重新安装Oracle后,用PL/SQL Developer ...

  8. 真机调试报错error ==Error Domain=NSURLErrorDomain Code=-1009 "似乎已断开与互联网的连接。"

    真机调试报错error ==Error Domain=NSURLErrorDomain Code=-1009 "似乎已断开与互联网的连接." 请注意,错误代码是-1009,网上关于 ...

  9. 基于jQuery滑动分步式进度导航条代码

    分享一款基于jQuery滑动分步式进度导航条代码.这是一款基于jquery实现的网站注册动态步骤导航条代码.效果图如下: 在线预览   源码下载 实现的代码. html代码: <div id=& ...

  10. java框架篇---struts之OGNL详解

    OGNL(Object Graph Navigation Language),是一种表达式语言.使用这种表达式语言,你可以通过某种表达式语法,存取Java对象树中的任意属性.调用Java对象树的方法. ...