乐趣区

关于java:Java基础10内部类和多态

jiezi

1. 外部类

在 java 中能够把类定义在另个类的外部，咱们称之为外部类，外层的类为外部类。在一个类的外部有一个残缺的构造，而这个内部结构只为外部类提供服务。外部类能够更不便的拜访外部类成员，外部类更好的提供封装性，能够用权限修饰符更好的管制。

// 格局
public class 类名 {
    // 外部类
    权限修饰符 [static] class 外部类名称 {...}
}

1.1 动态外部类

动态外部类是应用 static 润饰的类，属于外部类的一部分。他的特点和一般类一样，只是地位不同。

// 格局
public class Outer {
    public static class Inner {...}
}
public class StaticInnerClass1 {
    public static String str = "Version 1.0";
    public static int num = 10;
    private String name;

    public static class Inner {
        private String type;
        private int age;

        public Inner() {}

        public Inner(String type, int age) {
            this.type = type;
            this.age = age;
        }

        public void show() {System.out.println(str);
            System.out.println(num);
        }

        public String getType() {return type;}

        public void setType(String type) {this.type = type;}

        public int getAge() {return age;}

        public void setAge(int age) {this.age = age;}
    }

    public String getName() {return name;}

    public void setName(String name) {this.name = name;}

    public static void main(String[] args) {
    // 外部类实例化
        StaticInnerClass1.Inner inner = new StaticInnerClass1.Inner();
        inner.show();}
}

留神：

动态外部类能够间接拜访外部类动态成员
动态外部类不能间接拜访内部实例成员

1.2 成员外部类

成员外部类和动态外部类类似，只是不加 static 关键字修饰符。在 jdk1.6 之前不能在成员外部类定义动态成员，之后版本能够定义。

// 格局
修饰符 class 类名 {
    ...
    修饰符 class 外部类类名 {...}
}
// 成员外部类调用
外部类. 外部类 对象名 = new 外部类结构器().new 外部类结构器()
// 示例
public class MemberInnerClass {

    public static int flag = 0;

    private String name;
    private int age;

    public MemberInnerClass() {}

    public MemberInnerClass(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public class Inner {

        private String sex;
        private int num;

        public Inner() {}

        public Inner(String sex, int num) {
            this.sex = sex;
            this.num = num;
        }

        public void show() {System.out.println(flag);
            System.out.println(name);
            System.out.println(age);
            System.out.println(sex);
            System.out.println(num);
        }

        public String getSex() {return sex;}

        public void setSex(String sex) {this.sex = sex;}

        public int getNum() {return num;}

        public void setNum(int num) {this.num = num;}
    }

    public String getName() {return name;}

    public void setName(String name) {this.name = name;}

    public int getAge() {return age;}

    public void setAge(int age) {this.age = age;}

    public static void main(String[] args) {MemberInnerClass.Inner inner = new MemberInnerClass("张三", 18).new Inner("男", 1);
        inner.show();}
}

特点：

  • 属于外部类的对象，与类特色统一
  • 不能创立动态成员，动态成员须要应用 final
  • 能够间接拜访内部成员和动态成员

1.3 部分外部类

这是一个比拟很怪异的语法，失常状况很少应用，只做理解。

部分外部类放在代码块、结构器和办法中。

// 示例
public class PartialInnerClass {
    {class Dog{}

        Dog dog = new Dog();}

    public PartialInnerClass() {class Cat{}
        Cat cat = new Cat();}

    public static void main(String[] args) {class Pig{}
        Pig pig = new Pig();}
}

1.4 匿名外部类

匿名外部类实质上就是一个没有名称的部分外部类，次要定义在办法和代码块中。最次要的指标是为了简化代码。

// 格局
new (类 | 抽象类 | 接口) {...}

特点：
匿名外部类是一个没有名称外部类
匿名外部类编写进去即创立出一个匿名对象
匿名外部类创立进去的为以后类的子类

// 示例
public interface AnonymousInnerClass {void show();

    static void main(String[] args) {AnonymousInnerClass anonymousInnerClass = new AnonymousInnerClass() {
            @Override
            public void show() {System.out.println("匿名类创立");
            }
        };
        anonymousInnerClass.show();}
}

从下面能够看出，AnonymousInnerClass 貌似间接创立了对象，但理论并非如此。anonymousInnerClass 实例取得到的对象其实是接口的实现类或者子类。这是匿名外部类的个性，创立即生成子类。子类对象能够间接赋值给父类，这就是多态，面对对象的三大个性之一，接下来咱们行将介绍这部分内容。

1.5 外部类示例

以下示例显示了如何调用局部变量、成员变量和外部类成员变量

public class Other {

    private int number = 10;

    public class Inner {
        private int number = 5;

        public void show() {
            int number = 2;
            // 2
            System.out.println(number);
            // 5
            System.out.println(this.number);
            // 10
            System.out.println(Other.this.number);
        }
    }

    public static void main(String[] args) {Inner inner = new Other().new Inner();
        inner.show();}
}

2. 多态

同类型对象，在执行雷同行为时会呈现不同的特色。举一个简略的例子，狗和猫都能够形象成类，这些类又能够是动物类的子类。那么猫和狗都是动物的子类，都来实现叫声，当执行不同子类叫声行为时，后果就会不一样。

2.1 格局及成员拜访特点

// 格局
类 对象 = new 子类()

接口 对象 = new 实现类()

拜访特点：

  • 变量：编译和调用都看父类
  • 办法：编译看父类，调用看子类

2.2 多态优劣

优：

  • 解耦、便于扩大和保护
  • 形参能够定义父类，传递实参为子类即可，体现出扩展性。

劣：

  • 多态状况下，不能应用子类的独有性能

2.3 类型转换

主动类型转换：子类或者实现类实例对象能够间接赋值给父类或接口

强制类型转换：相似根底类型强制转换，子类 对象变量 =（子类）父类类型变量，此种转换也解决了不能应用子类独立性能弊病。

强制类型转换问题：

- 如果子类不是父类真正子类，则会抛出异样 ClassCastException
- 强制类型转换个别应用 instanceof 进行判断
// 格局
类变量 instanceof 类名
// 返回后果为 boolean 类型

2.4 示例

// 接口
public interface Animal {void bark();
}

public class Cat implements Animal{
    @Override
    public void bark() {System.out.println("小猫收回喵喵叫声。。。");
    }
}

public class Dog implements Animal {
    @Override
    public void bark() {System.out.println("小狗收回汪汪汪叫声。。。");
    }
}

public class Demo {public static void getBark(Animal animal) {animal.bark();
    }

    public static void main(String[] args) {
        // 收回喵叫
        getBark(new Cat());

        // 收回狗叫
        getBark(new Dog());
    }
}

本章完结，用于集体学习和小白入门，大佬勿喷！心愿大家多多点赞珍藏撑持撑持！

源码【GitHub】【码云】

退出移动版