Java面向对象（5） —— 内部类、面向对象

一、内部类

1、成员内部类：不常用
　　（a）类中套类，外面的叫外部类，里面的叫内部类
　　（b）内部类通常只服务于外部类，对外不具备可见性
　　（c）内部类对象通常是在外部类中创建的
　　（d）内部类中可以直接访问外部类的成员（包括私有的）
　　　　内部类中有个隐式的引用指向创建它的外部类对象，语法：外部类名.this

class Outer{
    private int time;

    class Inner{
        public void timeInc(){
            time++;
        }
    }
}

class Outer{
    private int time;
    private Inner inner;

    Outer(int time){
        this.time =time;
        inner = new Inner();
        inner.timeInc();
    }

    public void printTime(){
        System.out.println(time);
    }

    class Inner{
        public void timeInc(){
            time++;
        }
    }
}

Outer outer = new Outer(100);
outer.printTime();
//输出结果为101

2、匿名内部类：比较常用
　　如果在一段程序中需要创建一个类的对象（通常这个类需要实现某个接口或者继承某个类），而且对象创建后，这个类的价值也就不存在了，这个类可以不必命名，称之为匿名内部类。
　　SuperType obj = new SuperType(…){
　　　　//匿名内部类中定义的成员变量和方法
　　};

　　匿名内部类中访问外部的数据，该数据必须是final的。

public interface Action{
    public void execute();
}

public class Main{
    public static void main(String[] args){
        //1、创建了Action的一个子类，没有名字
        //2、为该子类创建了一个对象，引用叫action
        //3、大括号中的为子类的类体
        Action action = new Action(){
            public void execute(){
                System.out.println("Hello,World");
            }
        };
        action.execute();//代码中创建了实现了Action接口的内部匿名类对象，并调用其execute方法。
    }
}

　　内部类编译后会生成自己独立的.class文件。

---

二、多态

1、意义
　　（a）同一类型的引用指向不同的对象时，有不同的实现（子类继承实现了父类的抽象方法）
　　　　　行为的多态
　　（b）同一对象被造型为不同的类型时，有不同的功能（子类实现了多接口，向上造型为不同的接口类型时）
　　　　　对象的多态
2、向上造型
　　（a）父类型的引用指向子类的对象
　　（b）能造型成的类型有：
　　　　　　父类型、实现的接口
　　（c）能点出来什么，看引用的类型
3、强制类型转换，成功的条件有两个：
　　（a）引用所指向的对象，就是该类型
　　（b）引用所指向的对象，实现了该接口
　　如果在强制转换过程中不符合上述两个条件之一，将会抛出ClassCastException异常。
4、通过instanceof来判断引用是否是某种类型
　　instanceof返回boolean结果
　　强转成功的条件就是它为true的条件

---

三、面向对象三大特征

1、封装：
　　（1）类：封装的是对象的属性和行为
　　（2）方法：封装的是具体的逻辑功能实现
　　（3）访问控制修饰符：封装的是访问的权限
2、继承：
　　（1）作用：避免代码重复，有利于代码的重用
　　（2）父类：所有子类所共有的属性和行为
　　　子类：子类所特有的属性和行为
　　（3）子继承（extends）父后，子具有：父+子
　　（4）传递性、单一继承、多接口实现
3、多态：
　　（1）行为的多态、对象的多态
　　（2）向上造型、强制类型转换、instanceof
　　（3）多态的表现形式：重写+重载

package oop.day06;

public class CastTest {
    public static void main(String[] args) {
        //向上造型
        Aoo a1 = new Boo();   //向上造型
        Inter1 a2 = new Boo(); //向上造型
        //Inter1 a3 = new Coo(); //错误，类型不匹配

        //向上造型时，点出来什么，看类型
        Aoo b1 = new Boo();  //向上造型
        b1.b();  //正确
        //b1.num1=5; //编译错误，点出来什么看类型

        //强转时看对象
        Aoo c1 = new Boo(); //向上造型
        Boo c2 = (Boo)c1;   //c1指向的对象是Boo
        Inter1 c3 = (Inter1)c1;
                    //c1指向的对象实现了Inter1接口
        //Coo c4 = (Coo)c1; //类型转换异常
                   //c1指向的对象与Coo无关
        //instanceof为true两种情况:
        //1.对象为该类型
        //2.对象实现了该接口
        if(c1 instanceof Coo){  //false
            Coo c4 = (Coo)c1;
        }
    }
}

interface Inter1{
    void a();
}

abstract class Aoo{
    abstract void b();
}

class Boo extends Aoo implements Inter1{
    int num1;
    void b(){}
    public void a(){}
}

class Coo extends Aoo{
    int num2;
    void c(){}
    void b(){}
}

---

四、面向对象设计原则

1、将公共的属性和行为封装到父类中。
2、所有子类的行为都一样 — 普通方法
　 所有子类的行为不一样 — 抽象方法
3、若符合即是也是原则时，使用接口（继承只能继承一个父类，但接口可以实现多个）