面向对象(多态与内部类)

多态

多态的概述：多态是继封装，继承以后，面向对象的第三大特性。是指同一行为，具备多个不一样表现形式，为多态。

举个生活栗子：生活中，好比跑的动做，小猫、小狗和大象，跑起来是不同的。再好比飞的动做，昆虫、鸟类和飞机，飞起来也是不同的。可见，同一行为，经过不一样的事物，能够体现出来的不一样的形态。多态，描述的就是这样的状态。

java实现多态条件：

• 继承：在多态中必须存在有继承关系的子类和父类
• 重写：子类对父类中某些方法进行从新定义，在调用这些方法时就会调用子类的方法
• 向上转型：在多态中须要将子类的引用赋给父类对象，只有这样该引用才既能能够调用父类的方法，又能调用子类的方法

代码简略实现：

public class Dome01 {
    public static void main(String[] args) {
        Fu fu = new Fu();  //建立父类对象
        fu.print();        //咱们能够调用父类的公共方法print不能访问name私有方法
        
        Zi zi = new Zi();  //建立子类对象
        zi.print();        //子类自动继承父类的print()方法，可是子类里也写了一个print方法，因此属于重写父类方法
        zi.run();          //子类继承父类可继承的方法或变量，因此能够经过子类调用run
        
        //多态----------------
        Fu zi2 = new Zi();    //建立子类对象，使用父类来承接
        zi2.print();          //和上面的子类对象调用同样，上面子类能调用发下面也能调用
        zi.run();
    }
}

class Fu {// 定义父类方法
    public void print() {
        System.out.println("我是父类的输出方法");
    }

    private void name() {
        System.out.println("我是父类的私有方法");
    }
    
    public void run() {
        System.out.println("我是父类的run方法");
    }
}

class Zi extends Fu { // 定义子类
    // 子类方法一
    @Override
    public void print() {
        System.out.println("我是子类的输出方法");
    }

    private void name() {
        System.out.println("我是子类的私有方法");
    }

}

虽然使用下面多态调用效果同样，可是调用的过程是有区别的

• 成员变量：编译看左边（父类），运行看左边（父类）   全部的成员变量取决于编译时类型

• 成员方法：编译看左边（父类），运行看右边（子类）   全部的成员方法取决于运行时类型

• 静态方法：编译看左边（父类），运行看左边（父类）   全部的静态方法取决于编译时类型

代码解释：

public class Dome02 {
    public static void main(String[] args) {
            Fu1 zi1 = new Zi1();
            System.out.println(zi1.a);  //输出的值为0,调用成员方法是编译时看父类的成员变量，运行时也运行父类的成员变量
            zi1.name();  //调用成员方法时，编译时，先看父类有没有该成员方法，若是有，就去看子类有没有，若是也有就执行子类的
            zi1.name2(); // 因为name02是静态方法，因此，调用时编译是看的是父类，因此运行时也会运行父类的,
            
            
            //调用静态方法和成员变量，静态的是属于各自类的不能继承也不能被重写
            Fu1.name2(); System.out.println(Fu1.b);
            Zi1.name2(); System.out.println(Zi1.b);
    }
}

class Fu1 {
    int a = 0;
    static int b = 1;

    public void name() {
        System.out.println("我是父类普通成员方法");
    }

    public static void name2() {
        System.out.println("我是父类静态成员方法");
    }
}

class Zi1 extends Fu1 {
    int a = 22;
    static int b = 11;

    @Override
    public void name() {
        System.out.println("我是子类普通成员方法");
    }

    public static void name2() { // 静态方法不能重写
        System.out.println("我是子类的静态成员方法");
    }
}

在调用成员方法时，子类若是没有重写，会默认继承父类的，因此运行依旧子类中的name()方法，但本质上这个name()方法依旧是父类的，但子类重写后，它的本质就变量，至关于子类从父类继承来了一块宝石，而后子类通过一系列的打磨，雕刻，它变成了一个工艺品，这个时候，这个工艺品就是子类独有的而并不是仍是原来的那个宝石。注：父类的方法在子类重写后仍能够经过父类对象调用

多态的好处： 可使程序编写的更简单，并有良好的扩展。

引用类型的转型：

 转型分为向上转型和向下转型两种。

向上转型 ：多态自己是子类类型向父类类型向上转换的过程，这个过程是默认的。当父类引用指向一个子类对象时，即是向上转型。

父类类型 变量名 = new 子类类型(); 
如：Animal a = new Cat();

向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。一个已经向上转型的子类对象，将父类引用转为子类引用，可使用强制类型转换的格式，即是向下转型。

子类类型 变量名 = (子类类型) 父类变量名; 
如:Cat c =(Cat) a;

instanceof关键字：

有时候，在转换类型的时候，程序员会看不到源码，因此咱们须要强转时，不知道该往哪个子类去转换，就会引起ClassCastException异常，为了处理这一个问题java提供了instanceof关键字。（相似于判断的意思） 演示以下：

public class MyTest3 { 
    public static void main(String[] args) { 
        // 向上转型 
        Animal a = new Cat(); 
        a.eat(); // 调用的是 Cat 的 eat 
        // 向下转型 
        if (a instanceof Cat){ 
            Cat c = (Cat)a; 
            c.catchMouse(); // 调用的是 Cat 的 catchMouse 
        } else if (a instanceof Dog){ 
            Dog d = (Dog)a; 
            d.watchHouse(); // 调用的是 Dog 的 watchHouse 
        } 
    } 
}

内部类

  内部类：顾名思义就是内部的类，在一个类A中定义一个类B这个时候   类A就会被称做外部类， 而类B就被称做内部类了。  内部类，有根据所处位置不一样，修饰符不一样来区分为四大内部类分别是：成员内部类   静态内部类  局部内部类  匿名内部类。

成员内部类：定义在类中方法外的类 ----代码以下：

public class Outer {
    class Inner {
        // 成员内部类
    }
}

成员内部类的注意点：

• 内部类能够直接访问外部类的成员，包括私有成员。

• 外部类要访问内部类的成员，必需要创建内部类的对象。

静态内部类：静态内部类是指使用 static 修饰的内部类。----代码以下：

public class Outer {
    static class Inner {
        // 静态内部类
    }
}

静态内部类注意点：

• 在建立静态内部类的实例时，不须要建立外部类的实例；

• 静态内部类能够直接访问外部类的静态成员，若是要访问外部类的实例成员，则须要经过外部类的实例去访问。

局部内部类：局部内部类是指在一个方法中局部位置定义的内部类。 ----代码以下:

public class Outer {
    public void method() {
        class Inner {
            // 局部内部类
        }
    }
}

局部内部类注意点：

• 局部内部类与局部变量同样，不能使用访问控制修饰符（public、private 和 protected）和 static 修饰符修饰；

• 局部内部类只在当前方法中有效；

• 局部内部类中不能定义 static 成员。

 匿名内部类：是内部类的简化写法，它的本质是一个 带具体实现的 父类或者父接口的 匿名的 子类对象。 ----代码以下：

 匿名内部类前提：存在一个类或者接口，这里的类能够是具体类也能够是抽象类。

public class Dome03 {
    public static void main(String[] args) {
        // 匿名内部类实现重写普通类的方法
        new test01() {
            @Override
            public void name() {
                // TODO Auto-generated method stub
            }
        };
        // 匿名内部类实现重写抽象类的抽象方法
        new test02() {
            @Override
            public void name() {
                // TODO Auto-generated method stub
            }
        };
        // 匿名内部类实现重写接口的抽象方法
        new test03() {
            @Override
            public void name() {
                // TODO Auto-generated method stub
            }
        };
    }
}

class test01 {
    public void name() {
        System.out.println("");
    }
}

abstract class test02 {
    public abstract void name();
}

interface test03 {
    void name();
}

匿名内部类的做用：

开发中，最经常使用到的内部类就是匿名内部类了。以接口举例，当你使用一个接口时，彷佛得作以下几步操做，

• 定义子类
• 重写接口方法
• 建立子类的对象
• 调用重写后的方法

咱们的目的，最终只是为了调用方法，那么能不能简化一下，把以上四步合成一步呢？匿名内部类就是作这样的快捷方式。

 模板设计模式

 模板设计模式定义：定义一个操做中的算法骨架，将通用步骤以模板形式封装在父类模板中，将具体细节步骤延迟到子类中实现。

如何理解，模板设计模式是将功能的细节封装起来，给外界一个公共的调用模板，咱们调用这个模板就能达到想要的需求。好比：咱们想在控制台打印三句话：我爱你java，我将好好学习java，我必定会成为一个好的工程师。使用模板设计模式以下：

public class Dome04 {
    public static void main(String[] args) {
        Test test = new Test();
        test.template();   //调用时咱们不须要知道代码实现的细节，直接调用模板方法就能完成需求
    }
}

class Test {
    // 细节是什么？？？ 细节就是三句话
    public void template() { // 定义公共模板
        // 公共模板调用三个细节
        print1();
        print2();
        print3();
    }

    // 使用private封装三个细节
    private void print1() {
        System.out.println("我爱你java");
    }

    private void print2() {
        System.out.println("我将好好学习java");
    }

    private void print3() {
        System.out.println("我必定会成为一个好的工程师");
    }
}

设计模式，属于一种写代码的思想，这里写非常简略，与我的学习有出入，是本身所理解的比较容易懂一些。了解更多细节：https://www.runoob.com/design-pattern/template-pattern.html 

 

我的学习，内容简略