Java基础22

Java 泛型

关键字说明

• ? 通配符类型
• <? extends T> 表示类型的上界，表示参数化类型的可能是T 或是 T的子类
• <? super T> 表示类型下界（Java Core中叫超类型限定），表示参数化类型是此类型的超类型（父类型），直至Object

• 子类不能继承父类的static成员

• 构造方法不能被继承。
• super 关键字的功能：
  • 调用父类中声明为 private 的变量。
  • 点取已经覆盖了的方法。
  • 作为方法名表示父类构造方法。
  • 通过 super 调用父类的隐藏变量，必须要在父类中声明 get方法，因为声明为 private 的数据成员对子类是不可见的。
    
  • • 在一个构造方法内只能调用一个构造方法。
    方法重写的原则：
    • 重写方法的返回类型、方法名称、参数列表必须与原方法的相同。
    • 重写方法不能比原方法访问性差（即访问权限不允许缩小）。
    • 重写方法不能比原方法抛出更多的异常。
    • 被重写的方法不能是final类型，因为final修饰的方法是无法覆盖的。
    • 被重写的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。
    • 被重写的方法不能为static。如果父类中的方法为静态的，而子类中的方法不是静态的，但是两个方法除了这一点外其他都满足覆盖条件，那么会发生编译错误；反之亦然。即使父类和子类中的方法都是静态的，并且满足覆盖条件，但是仍然不会发生覆盖，因为静态方法是在编译的时候把静态方法和类的引用类型进行匹配。
    
    方法的重载：
    前面已经对Java方法重载进行了说明，这里再强调一下，Java父类和子类中的方法都会参与重载，例如，父类中有一个方法是 func(){ ... }，子类中有一个方法是 func(int i){ ... }，就构成了方法的重载。
    
    重写和重载的不同：
    • 方法重写要求参数列表必须一致，而方法重载要求参数列表必须不一致。
    • 方法重写要求返回类型必须一致，方法重载对此没有要求。
    • 方法重写只能用于子类重写父类的方法，方法重载用于同一个类中的所有方法（包括从父类中继承而来的方法）。
    • 方法重写对方法的访问权限和抛出的异常有特殊的要求，而方法重载在这方面没有任何限制。
    • 父类的一个方法只能被子类重写一次，而一个方法可以在所有的类中可以被重载多次。
    使用内部类的主要原因有：
    • 内部类可以访问外部类中的数据，包括私有的数据。
    • 内部类可以对同一个包中的其他类隐藏起来。
    • 当想要定义一个回调函数且不想编写大量代码时，使用匿名(anonymous)内部类比较便捷。
    • 减少类的命名冲突。
    内部类可以相互调用
    
  • 局部内部类(Local class)是定义在代码块中的类。它们只在定义它们的代码块中是可见的。区分于成员内部类。
    
    局部类有几个重要特性：
    1. 仅在定义了它们的代码块中是可见的；
    2. 可以使用定义它们的代码块中的任何局部 final 变量；
    3. 局部类不可以是 static 的，里边也不能定义 static 成员；
    4. 局部类不可以用 public、private、protected 修饰，只能使用缺省的；
    5. 局部类可以是 abstract 的。
    匿名类必须继承一个父类或实现一个接口。一般用抽象类和接口来实现
    
  • 关于抽象类的几点说明：
    • 抽象类不能直接使用，必须用子类去实现抽象类，然后使用其子类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例，也就是可以使用抽象类来充当形参，实际实现类作为实参，也就是多态的应用。
    • 不能有抽象构造方法或抽象静态方法。 
    
    
    在下列情况下，一个类将成为抽象类：
    1. 当一个类的一个或多个方法是抽象方法时；
    2. 当类是一个抽象类的子类，并且不能为任何抽象方法提供任何实现细节或方法主体时；
    3. 当一个类实现一个接口，并且不能为任何抽象方法提供实现细节或方法主体时；注意：
       • 这里说的是这些情况下一个类将成为抽象类，没有说抽象类一定会有这些情况。
       • 一个典型的错误：抽象类一定包含抽象方法。 但是反过来说“包含抽象方法的类一定是抽象类”就是正确的。
       • 事实上，抽象类可以是一个完全正常实现的类
    接口的使用与类的使用有些不同。在需要使用类的地方，会直接使用new关键字来构建一个类的实例，但接口不可以这样使用，因为接口不能直接使用 new 关键字来构建实例。
    
    接口必须通过类来实现(implements)它的抽象方法，然后再实例化类。类实现接口的关键字为implements。
    
    如果一个类不能实现该接口的所有抽象方法，那么这个类必须被定义为抽象方法。
    
    不允许创建接口的实例，但允许定义接口类型的引用变量，该变量指向了实现接口的类的实例。
    
    一个类只能继承一个父类，但却可以实现多个接口。
    

• 静态代码块、构造代码块，构造方法的执行顺序：

  父类静态代码块→子类静态代码块→父类构造代码块→父类构造方法→子类构造代码块→子类构造方法

  final是一个关键字，可以用于修饰类，成员变量，成员方法。

  特点：

  1. 它修饰的类不能被继承。
  2. 它修饰的成员变量是一个常量。
  3. 它修饰的成员方法是不能被子类重写的。

  final修饰的常量定义一般都有书写规范,被final修饰的常量名称,所有字母都大写。

  final修饰成员变量,必须初始化,初始化有两种

  • 显示初始化；
  • 构造方法初始化。
    但是不能两个一起初始化

  final和private的区别：

  1. final修饰的类可以访问；
     private不可以修饰外部类，但可以修饰内部类（其实把外部类私有化是没有意义的）。
  2. final修饰的方法不可以被子类重写；
     private修饰的方法表面上看是可以被子类重写的，其实不可以，子类是看不到父类的私有方法的。
  3. final修饰的变量只能在显示初始化或者构造函数初始化的时候赋值一次，以后不允许更改；
     private修饰的变量，也不允许直接被子类或一个包中的其它类访问或修改，但是他可以通过set和get方法对其改值和取值。

  多态的成员特点：

  • 成员变量：编译时期：看引用型变量所属的类中是否有所调用的变量；
    运行时期：也是看引用型变量所属的类是否有调用的变量。
    成员变量无论编译还是运行都看引用型变量所属的类，简单记成员变量，编译和运行都看等号左边。
  • 成员方法：编译时期：要查看引用变量所属的类中是否有所调用的成员；
    运行时期：要查看对象所属的类中是否有所调用的成员。如果父子出现同名的方法,会运行子类中的方法,因为方法有覆盖的特性。
    成员方法编译看左边运行看右边。
  • 静态方法:编译时期：看的引用型变量所属的类中是否有所调用的变量；
    运行时期：也是看引用型变量所属的类是否有调用的变量。
    静态方法编译和运行都看等号左边。

  抽象关键字abstract不可以和哪些关键字共存？

  • final：如果方法被抽象，就需要被覆盖，而final是不可以被覆盖，所以冲突。
  • private：如果方法被私有了，子类无法直接访问，怎么覆盖呢？
  • static：不需要对象，类名就可以调用抽象方法。而调用抽象方法没有意义。

  接口中的成员修饰符是固定的！

  • 成员常量：public static final，接口里定义的变量是全局常量，而且修饰符只能是这三个关键字，都可以省略，常量名要大写。
  • 成员方法：public abstract，接口里定义的方法都是抽象的，两个修饰符关键字可省略。

  继承与实现的区别：

  • 类与类之间称为继承关系：因为该类无论是抽象的还是非抽象的，它的内部都可以定义非抽象方法，这个方法可以直接被子类使用，子类继承即可。只能单继承，可以多层继承。（(class)）
  • 类与接口之间是实现关系：因为接口中的方法都是抽象的，必须由子类实现才可以实例化。可以单实现，也可以多实现；还可以在继承一个类的同时实现多个接口。（(class) extends (class) implements (interface1,interface2…)）
  • 接口与接口之间是继承关系：一个接口可以继承另一个接口，并添加新的属性和抽象方法，并且接口可以多继承。（(interface) extends (interface1,interface2…)）

  抽象类和接口的区别：

  成员变量

  • 抽象类能有变量也可以有常量
  • 接口只能有常量

  成员方法

  • 抽象类可以有非抽象的方法,也可以有抽象的方法
  • 接口只能有抽象的方法

  构造方法

  -抽象类有构造方法
  -接口没有构造方法

  类与抽象类和接口的关系

  • 类与抽象类的关系是继承 extends
  • 类与接口的关系是实现 implements

  接口的思想特点：

  1. 接口是对外暴露的规则；
  2. 接口是程序的功能扩展；
  3. 接口的出现降低耦合性；(实现了模块化开发,定义好规则,每个人实现自己的模块,大大提高了开发效率)
  4. 接口可以用来多实现；
  5. 多个无关的类可以实现同一个接口；
  6. 一个类可以实现多个相互直接没有关系的接口；
  7. 与继承关系类似，接口与实现类之间存在多态性。

  内部类访问特点：

  • 内部类可以直接访问外部类的成员，包括私有成员。
  • 外部类要访问内部类的成员，必须要建立内部类的对象。

  abstract不能与final并列修饰同一个类。

  abstract 不能与private、static、final或native并列修饰同一个方法。、