从零开始学Java-05面向对象编程

一、继承

Java中的继承，是子类继承父类的特征和行为，使得子类实例具有父类的非private属性和方法，使子类具有和父类相同的行为： 特点是 父类是通用的方法，子类是具体的方法

class 子类 extends 父类{}
子类：派生类
父类： 超类

• 子类可以对父类进行扩展
• 子类可以用自己的方式实现父类的方法（重写？）
• Java的基础是单继承的，一个子类只能继承一个父类，但是可以多重继承
• 提高了类的耦合，减少了代码的复用

1、重写

子类对父类的允许访问的方法的实现过程重新编写，返回值和参数都不改变（外壳不变，核心重写）
好处在于子类可以根据需要，定义属于自己的行为

• 参数列表不变，
• 返回类型是父类的返回值的派生类，
• 异常不变，
• 访问权限不能更低
• final不能被重写，static不能被重写能被再次声明
• 构造方法不能被重写
• 不能抛出新的强制性异常

2、重载

一个类里面，方法名字相同，参数不同，返回类型可以相同可以不同，每个重载的方法必须有独一无二的参数类型列表

• 必须改变参数列表
• 可以改变返回值类型
• 可以改变修饰符
• 可以声明新的或者更广的异常
• 能在同一个类或者在一个子类中被重载
• 返回值类型不能做为重载函数的区分标准

二、多态

是一个行为具有不同的表现形式或形态的能力，一个接口使用不同的实例而执行不同的操作

• 消除类型之间的耦合关系
• 可替换
• 可扩充
• 接口性
• 灵活性
• 广泛性
  必要条件
• 继承
• 重写
• 父类引用指向子类：Parent p = new Child();

多态表现在：重写，接口，抽象类和抽象方法

1、对象转型

1.1、向上转型

父类引用转向子类 Parent p = new Child();
看new的谁，并且成功方法重写

• 优势在于 可以对参数进行统一设计

1.2 、向下转型

需要使用子类的一些特殊的定义处理的时候
使用需要强转

• 子类特殊的定义
• 需要明确的是 向下转型之前一定要先向上转型

三、抽象类

用abstract 关键字来定义抽象类
抽象类是不能被实例化的，我们可以通过实例化一个对象，来继承这个抽象类，从而继承抽象类的属性和方法

抽象方法

用abstract 关键字来声明抽象方法，只有方法名而没有方法体，方法没有大括号，直接接分号结束

• 如果一个类包含抽象方法，那么这个类一定是抽象类
• 子类必须重写父类的抽象方法，或者声明自身是抽象类
• 最终必须要有子类实现了该抽象方法，否则，从最初的父类到最终的子类都不能用来实例化对象。

只有抽象类的非抽象子类才能被实例化

四、接口

接口是一个抽象类型，抽象方法的集合，常以interface来声明，一个类通过继承接口的方式，从而继承接口的抽象方法
接口不是类，接口无法被实例化，但是可以被实现（implement），实现类要实现接口中描述的所有方法

五、枚举

Java中用enum关键字定义枚举
枚举是一种特殊的类，通常表示一组常量
每个枚举都是通过class在内部实现的，枚举都是 public static final

六、 泛型

通过向下转型可能存在的安全问题，希望通过泛型解决掉此类问题
ClassCaseException

定义

类中的属性和方法的参数与返回值的类型可以由对象实例化的时候多态的决定就需要在类定义的时候明确的定义占位符（泛型标记 ）// T,K ,？
不设置泛型类的时候，会自动设置为Object以保证程序的运行
实例化的时候进行泛型的设置，设置后；泛型类的属性就与当前对象绑定了，就不需要向下转型了

• 泛型之中只允许设置引用类型

通配符

引用传递问题：不设置泛型，方法之中就可以对数据进行修改
通配符的使用，可以让方法可以接收所有类型，但是方法里面不能修改

• ？extend 类 ：设置泛型的上限；类及其子类
• ？ super 类； 设置泛型的下限；类及起父类

泛型接口

interface xxx<T>{   public void xxx(T t); }

泛型方法

将泛型标记写在方法上；泛型方法不一定是在泛型类

七、内部类

一个类的内部定义其他的类

class OuterClass {   // 外部类
    // ...
    class NestedClass { // 嵌套类，或称为内部类
        // ...
    }
}

内部类的优势在于轻松的访问内部类的私有属性

非静态内部类

使用的时候需要先实例化外部类，然后创建内部类的对象来实现

	OuterClass myOuter = new OuterClass();
    OuterClass.InnerClass myInner = myOuter.new InnerClass();
    System.out.println(myInner.y + myOuter.x);

私有的内部类

常用private和protected 来修饰

class OuterClass {
  int x = 10;

  private class InnerClass {
    int y = 5;
  }
}

静态内部类

可以用static关键字定义，不需要创建外部类类访问

class OuterClass {
  int x = 10;

  static class InnerClass {//无法访问外部类的成员
    int y = 5;
  }
}
public class MyMainClass {
  public static void main(String[] args) {
    OuterClass.InnerClass myInner = new OuterClass.InnerClass();
    System.out.println(myInner.y);
  }
}

内部类访问外部类的成员

class OuterClass {
  int x = 10;

  class InnerClass {
    public int myInnerMethod() {
      return x;
    }
  }
}

public class MyMainClass {
  public static void main(String[] args) {
    OuterClass myOuter = new OuterClass();
    OuterClass.InnerClass myInner = myOuter.new InnerClass();
    System.out.println(myInner.myInnerMethod());
  }
}

匿名内部类

是一种简化的内部类的处理形式，主要在抽象类和接口中使用，常用于事件监听

private void setListener()
{
    scan_bt.setOnClickListener(new Listener1());       
    history_bt.setOnClickListener(new Listener2());
}
class Listener1 implements View.OnClickListener{
    @Override
    public void onClick(View v) {
    // TODO Auto-generated method stub           
    }
}
class Listener2 implements View.OnClickListener{
    @Override
    public void onClick(View v) {
    // TODO Auto-generated method stub       
    }
}