ava深入学习面向对象

Java深入学习面向对象

一、面向对象之接口

       在前一遍博文初识面向对象中我们已经已经学习了抽象类，当一个抽象类中方法全部为抽象方法时此时该抽象类可以用另外一种形式定义个表示这就是Interface接口。

      对于接口中常见的成员都有固定的修饰符。全局变量的修饰符是public static final，抽象方法的修饰符是public abstract，即便我们不写也会被自动加上。

      接口不可以被实例化，只能由实现了该接口的子类覆盖了接口中的所有方法后，该子类才能实例化否则这个子类就是一个抽象类。前面为博文中说了Java不支持多继承对C++的多继承进行了改良就是接口的多实现，一个类可以实现多个接口。接口的出现避免了单继承的局限性。使用了extends关键字类与父类之间是继承关系，使用了implements的类与接口之间是实现关系，接口与接口之间是继承关系，而且接口可以多继承。

<span style="font-size:14px;"><span style="font-size:14px;">public class InterfaceTest implements People{@Overridepublic void move() {}@Overridepublic void think() {}@Overridepublic void control() {}}interface Hand{void move();}interface Head{void think();}interface People extends Hand,Head{void control();}</span></span>

接口和抽象类的区别

(1)相同点

     都是被不断的向上抽取出来的。

(2)不同点

     1.抽象类只能被继承而且是单继承，接口需要被实现而且可以是多实现

     2.抽象类中可以定义抽象方法和非抽象方法，子类继承后可以直接使用非抽象方法，接口中只能定义抽象方法，子类必须实现

     3.抽象类的继承是is a的关系，在定义该体系的基本共性内容，接口的实现是like a关系在定义体系的额外功能。

二、面向对象之多态

     多态简单点说就是一个对象的在不同运行时期的多种表现形态，如父类或者是接口指向子类对象。

<span style="font-size:14px;"><span style="font-size:14px;">public class Polymorphism {public static void main(String[] args) {control(new Pig());control(new Cat());control(new Panda());}public static void control(Animal a){a.eat();}}class Pig extends Animal{@Overridepublic void eat() {System.out.println("猪吃饲料");}}class Cat extends Animal{@Overridepublic void eat() {System.out.println("猫吃耗子");}}class Panda extends Animal{@Overridepublic void eat() {System.out.println("熊猫吃竹子");}}abstract class Animal{public abstract void eat();}</span></span>

运行效果截图

       多态的好处就是提高代码的扩展性，前期定义的代码可以使用后期的内容。多态的弊端就是前期定义的内容不能调用后期子类中特有的内容。

       使用多态的前提必须有关系，继承，实现，要有覆盖。

       现在想象如果熊猫的类中有其特有方法在测试类中的control方法中使用，那么就需要将Animal进行强转为了确保强制类型转换成功那么就需要在强制类型转换前进行类型的比较，所以就有了instanceof关键字。上面的代码改造成下面的样子

<span style="font-size:14px;"><span style="font-size:14px;">public class Polymorphism {public static void main(String[] args) {control(new Pig());control(new Cat());control(new Panda());}public static void control(Animal a){if (a instanceof Panda) {Panda panda = (Panda)a;((Panda) a).play();}a.eat();}}class Pig extends Animal{@Overridepublic void eat() {System.out.println("猪吃饲料");}}class Cat extends Animal{@Overridepublic void eat() {System.out.println("猫吃耗子");}}class Panda extends Animal{@Overridepublic void eat() {System.out.println("熊猫吃竹子");}public void play(){System.out.println("我是熊猫我在玩");}}abstract class Animal{public abstract void eat();}</span></span>

运行截图

多态的成员变量例子看下面的代码

<span style="font-size:14px;"><span style="font-size:14px;">public class Polymorphism {public static void main(String[] args) {Parent p = new Child();System.out.println(p.number);}}class Parent{int number = 3;}class Child extends Parent{int number = 4;}</span></span>

运行效果结果是3

多态中的成员变量不管是在编译时期还是在运行时期都是看左边比如上面的Parent p  = new Child();Child被自动提升为了Parent了所以在下面的调用number成员变量时打印的结果是父类中的3。

多态的成员函数例子看下面的例子

<span style="font-size:14px;"><span style="font-size:14px;">public class Polymorphism {public static void main(String[] args) {Parent p = new Child();p.show();}}class Parent{public void show(){System.out.println("我是父类的方法");}}class Child extends Parent{public void show(){System.out.println("我是子类的方法");}}</span></span>

我们看到调用和打印出来的是我是子类的方法。这种情况下必须通过对象来调用方法，需要动态绑定到指定的对象上
多态的静态成员函数举例

<span style="font-size:14px;"><span style="font-size:14px;">public class Polymorphism {public static void main(String[] args) {Parent p = new Child();p.show();}}class Parent{public static void show(){System.out.println("我是父类的方法");}}class Child extends Parent{public static void show(){System.out.println("我是子类的方法");}}</span></span>

运行结果是"我是父类的方法"

三、面向对象之内部类

(1)初识内部类       

     内部类就是指将一个类定义在另外的一个类的内部，里面的那个类就称为内部类。或者是内嵌类或者是内置类。内部类的特点就是内部类可以直接访问外部类中的成员，包括私有成员，而外部类要访问内部类总的成员必须通过内部类的实例对象来才可。

     什么时候创建内部类呢？在分析事物的时候发现事物中还有事物，而且这个事物还在访问被描述的事物的内容，这时就需要在描述事物的类中继续定义内部类来解决。

(2)内部类的修饰符

     1.内部类没有修饰符

<span style="font-size:14px;">class Outer {class Inner{}}public class MainTest{public static void main(String[] args) {Outer.Inner in = new Outer().new Inner();}}</span>

     2.内部类被static修饰,相当于外部类

<span style="font-size:14px;">class Outer {static class Inner{}}public class MainTest{public static void main(String[] args) {Outer.Inner in = new Outer.Inner();}}</span>

    3.如果内部类没有被static关键字修饰而内部类中定义了静态方法这是不被允许的。会报错误就是内部类中不允许有静态声明。
(3)内部类中的细节问题

<span style="font-size:14px;">class Outer {private int number  = 3;class Inner{private int number = 4;void show(){int number = 5;System.out.println(number);System.out.println(Inner.this.number);System.out.println(Outer.this.number);}}public void test(){new Inner().show();}}public class MainTest{public static void main(String[] args) {new Outer().test();}}</span>

运行结果5,4,3
(4)局部内部类，对于内部类来说只能访问被final关键字修饰的局部变量特别注意这是对于JDK1.8版本以下的来说的，JDK1.8版本访问正常，下面代码在低于1.8版本需要在x前加上final关键字。

<span style="font-size:14px;">class Outer { void show(){int x = 5;class Inner{void print(){System.out.println(x);}}new Inner().print();}}public class MainTest{public static void main(String[] args) {new Outer().show();}}</span>

(5)匿名内部类

    匿名内部类就是内部类的简写形式，前提是内部类必须继承或者是实现一个外部类或者是接口。

下面我们来创建一个Object对象的内部类

<span style="font-size:14px;">class Outer { void show(){new Object(){void run(){System.out.println("我是运行时刻");}}.run();}}public class MainTest{public static void main(String[] args) {new Outer().show();}}</span>

这样是正常的，但是下面这样是错误的。

<span style="font-size:14px;">class Outer { void show(){Object obj = new Object(){void run(){System.out.println("我是运行时刻");}};obj.run();}}public class MainTest{public static void main(String[] args) {new Outer().show();}}</span>

因为被向上转型了所以特有的方法被隐藏掉了。