2.12Java基础学习

多态

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

实现方式：重写、接口、抽象类和抽象方法

优点：消除类型之间的耦合关系、可替换性、可扩充性、接口性、灵活性、简化性

必要条件：继承、重写、父类引用指向子类对象

---

final 关键字

final 可以用来修饰变量（包括类属性、对象属性、局部变量和形参）、方法（包括类方法和对象方法）和类。

使用 final 关键字声明类，就是把类定义定义为最终类，不能被继承，或者用于修饰方法，该方法不能被子类重写：

//声明类：
final class 类名 {//类体}

//声明方法：
修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}

---

抽象类

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。

父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。

在 Java 中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

在 Java 语言中使用 abstract class 来定义抽象类

/* 文件名 : Employee.java */
public abstract class Employee
{
   private String name;
   private String address;
   private int number;
   public Employee(String name, String address, int number)
   {
      System.out.println("Constructing an Employee");
      this.name = name;
      this.address = address;
      this.number = number;
   }
   public double computePay()
   {
     System.out.println("Inside Employee computePay");
     return 0.0;
   }
   public void mailCheck()
   {
      System.out.println("Mailing a check to " + this.name
       + " " + this.address);
   }
   public String toString()
   {
      return name + " " + address + " " + number;
   }
   public String getName()
   {
      return name;
   }
   public String getAddress()
   {
      return address;
   }
   public void setAddress(String newAddress)
   {
      address = newAddress;
   }
   public int getNumber()
   {
     return number;
   }
}

/* 文件名 : AbstractDemo.java */
public class AbstractDemo
{
   public static void main(String [] args)
   {
      /* 以下是不允许的，会引发错误 */
      Employee e = new Employee("George W.", "Houston, TX", 43);
 
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
    }
}
//编译结果
/*
Employee.java:46: Employee is abstract; cannot be instantiated
      Employee e = new Employee("George W.", "Houston, TX", 43);
                   ^
1 error
*/

---

接口

接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。

接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

接口与类相似点：

1、一个接口可以有多个方法。

2、接口文件保存在 .java 结尾的文件中，文件名使用接口名。

3、接口的字节码文件保存在 .class 结尾的文件中。

4、接口相应的字节码文件必须在与包名称相匹配的目录结构中。

接口与类的区别：

1、接口不能用于实例化对象。

2、接口没有构造方法。

3、接口中所有的方法必须是抽象方法，Java 8 之后 接口中可以使用 default 关键字修饰的非抽象方法。

4、接口不能包含成员变量，除了 static 和 final 变量。

5、接口不是被类继承了，而是要被类实现。

6、接口支持多继承。

接口的声明语法格式

[可见度] interface 接口名称 [extends 其他的接口名] {
        // 声明变量
        // 抽象方法
}

//实例
/* 文件名 : NameOfInterface.java */
import java.lang.*;
//引入包
 
public interface NameOfInterface
{
   //任何类型 final, static 字段
   //抽象方法
}

---

枚举

Java 枚举是一个特殊的类，一般表示一组常量，比如一年的 4 个季节，一年的 12 个月份，一个星期的 7 天，方向有东南西北等。

Java 枚举类使用 enum 关键字来定义，各个常量使用逗号 , 来分割。

enum Color 
{ 
    RED, GREEN, BLUE; 
} 
  
public class Test 
{ 
    // 执行输出结果
    public static void main(String[] args) 
    { 
        Color c1 = Color.RED; 
        System.out.println(c1); 
    } 
}

//结果
/*
RED
*/

---

泛型

Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。

泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

转型

//转型是基于继承，所以先实现一个子类继承父类
/**
 * 父类
 */
class Father {
	String name = "爸爸";
	public void sleep() {//睡觉方法
		System.out.println(name + "睡觉");
	}
}
/**
 * 子类继承父类
 */
class Son extends Father {
	String name = "儿子";
	public void p() {//调皮方法
		System.out.println(name + "调皮");
	}
}

//向上转型
public class UpAndDown {
	public static void main(String[] args) {
		// 向上转型：将父类引用指向子类对象
		Father f = new Son();
		f.sleep();//输出“爸爸睡觉”
      
        //如果f.p();编译出错，不可执行。因为p()不是Father的方法。
	}
}

//向下转型
public class UpAndDown {
	public static void main(String[] args) {
		// 向下转型
		Father f = new Son();
		((Son)f).P();//输出“儿子调皮”
	}
}