javaSE第四章面向对象——封装、继承、多态

封装

封装的概念：将类的某些信息隐藏在类内部，不允许外部程序直接访问， 而是通过该类提供的方法来实现对隐藏信息的操作和访问
封装的好处：只能通过规定方法访问、只能通过规定方法访问、方便加入控制语句、方便修改实现
具体表现为在类中使用不同的访问权限，例如：

      public class Demo{ 
           private String name; 
           public String getName (){ 
                return name; 
           }
           public void setName(String name){ 
                this.name = name; 
           } 
     }

单例模式

需要在某个类在整个应用程序中，只能创建一个对象
单例模式：将构造方法私有化，在程序的其他地方不能随意调用构造方法
再给外界创建一个静态方法，用来获得创建的唯一对象，这样在类内部控制起来就比较方便

懒汉单例

它是单例模式的一种简单实现，比较方便，但它存在一些问题，此代码会让多个线程访问，因为线程的休眠机制会导致创建多个对象
例子如下：

public class Demo {    
    static  Demo  Demo1;    
    private  Demo(){ 
    }    
    public static Demo Demo1(){                               
    if(Demo1==null){            
             Demo1=new Demo();       
           }        
             return Demo1;   
     }
}

饿汉单例

饿汉单例又称急切式单例，它在加载类的时候，就直接将对象创建，由于是静态，所以只加载一次它不存在什么问题
例子如下：

public class Demo {    
    static  Demo  Demo1=new Demo();    
    private  Demo(){    
    }    
    public static Demo Demo1(){                            
     return Demo1;    
    }
}

继承

继承：继承是面向对象程序设计不可缺少的设计思想，是实现代码可重用的根基，是提高代码可扩展性的主要途径
继承是从已有的类中派生出新的类，新的类能吸收已有类的属性和行为， 并能扩展新的能力

• 在JAVA中使用extends关键字来表示继承关系
• JAVA不支持多继承，单继承使JAVA的继承关系很简单，一个类只能有一个直接父类
• 继承之后子类可以调用父类的所有非私有属性和非私有方法
• 继承是代码重用的一种方式
• 继承与真实世界类似，符合is-a关系的设计,使用继承，将子类共有的属性和行为放到父类中,比如猫是动物，狗也是动物，动物就是猫和狗的父类，狗和猫就是动物的子类，所有动物共有的属性和行为就可以放到动物类中。
  继承的形式：

          [访问权限修饰符][修饰符] 子类名 extends 父类名{子类体}

例如：

          public class Animal{ 
              public void eat(){} 
           }
           public class Dog extends Animal{ 
           public void play(){} 
           }
          //子类对象可以直接调用父类的方法，强调复用性 
         Dog dog = new Dog (); 
         dog.eat();

继承的传递性

C类从B类继承,B类又从A类继承 那么C类就具有B类和A类的所有非私有属性和非私有方法，当一个没有继承任何一个类时,jvm会默认让类继承Object类 Object是 java为所有类提供的基类

继承中的构造方法

子类构造方法会先调用父类构造方法，使用super关键字调用父类任意一个构造方法,必须写在构造方法的第一行 如果子类的构造方法中没有显式地调用基类构造方法，则系统默认调用基类无参数的构造方法

super关键字用途

使用super关键字访问父类成员

• 用super.成员变量名来引用父类成员变量
• 用super.方法名（参数列表）访问父类的方法。
• 用super.构造方法(参数列表)访问父类构造方法
  不要把super误认为是父类对象.在创建子类对象时, 不会创建父类对象. 只会将父类中的信息加载到子类对象中存储

方法的重写

应用场景 当父类的方法实现不能满足子类需求时,可以对方法进行重写( override)
在子类中可以根据需要对从基类中继承来的方法进行重写。
方法重写规则

• @Overrid表示此方法是从父类方法中重写而来
• 方法名相同、参数列表相同；
• 返回值类型相同；
• 访问权限不能小于父类权限;
  注意：构造方法,静态方法不能重写,成员变量不存在重写

多态

多态：同一种事物，在不同时刻表现不同的状态
多态存在的三个必要条件

• 要有继承（包括接口的实现）(前提条件)
• 要有重写(前提条件)
• 父类引用指向子类对象
  当编译期类型是父类，运行期类型是子类时，被称为父类引用指向子类对象

        class Animal{ …… }
        class Cat extends Animal{ …… }
        class Dog extends Animal { …… }
        Animal x = new Cat() 
        //Animal 的引用指向Cat的对象

多态环境下对成员方法的调用
示例如下：

            class Animal{ 
               void show() { 
                  System.out.println(“Anmial"); 
                } 
             } 
             class Cat extends Animal{ 
             void show() { 
             System.out.println(“cat"); 
             } 
             }
             ……. 
             Animal x = new Cat() x.show() //调用的是子类中的方法

简单的说：编译看左边，运行看右边
多态环境下对成员变量的调用
示例如下：

                class Animal{ 
                 int num = 3; 
                 }
                 class Cat extends Animal { 
                 int num = 4; 
                 }
                 ……. 
                 Animal x = new Cat() x.num; //调用的是动物类中的成员变量。

简单的说：编译和运行都看等号左边。
注意：变量不存在被子类覆写这一说法，只有方法存在覆写。
方法参数具有多态性
示例如下：

                 class Animal{  
                 void eat() {} 
                 }class Cat extends Animal{ 
                 void eat() {} 
                }
                 class Dog extends Animal{ 
                 void eat(){} 
                 }
                 //方法的形式参数类型是父类类型，而传递的实际参数可以是任意子类的对象 
                 method(Animal animal){ 
                 animal .eat(); 
                 }

方法参数多态性的好处：提高代码的扩展性
向上转型
将子类类型向上转为父类类型

                class Animal{ 
                void eat(){ } 
                }
                class Cat extends Animal{ 
                void look() {
                 System.out.println("看家");
                } 
                } 
                  ……… 
                  Animal x=new Cat() //向上造型，Cat对象提升到Animal对象 
                  x.eat() //只能使用父类中的方法 
                  x.look() //报错！不能使用子类中的方法

向上转型的作用是：提高程序的扩展性。
向下转型
将父类类型向下转为子类类型

               class Animal{ 
               void eat(){} 
               }
               class Cat extendsAnimal{ 
               void look() { 
               System.out.println("看家"); 
               } 
               } 
               ……… 
               Animal x=new Cat() 
               Cat m=(Cat)x; //向下转型 
               m.eat() ; 
               m.look();//子父类中的方法都可以使用

向下转型的作用是：为了使用子类中的特有方法。