java基础（四）类继承、多态、接口、包与 System类、Scanner类和Math类

继承

1.java类继承
java中继承由关键字extends实现，格式如下：

[修饰符]  class 类名称  extends  超类名称
{
      域（字段）声明
      方法声明
      ......
}

java不支持多继承关系，一个子类只能有一个超类
修饰符

• public 公有的
• private 私有的
• protected 保护的
• 默认 包私有
• static 静态的
• final 最终的
• abstract 抽象的，不能被实例化

2.访问控制
访问权限：

3.super关键字
super关键字表示超类的引用，可用super：

• 访问超类成员
• 在子类构造方法中使用超类构造方法

域的继承与隐藏

1.域的继承

• 子类继承父类所有的public和protected成员，不管他们是不是在同一个包中
• 如果子类和父类在同一个包中，它也能继承父类的package-private成员

2.域的隐藏
在子类中定义一个与从父类那里继承来的名字相同的域，称为域的隐藏

方法隐藏、覆盖、继承

1.方法继承

• 子类继承父类所有的public和protected方法，不管他们是不是在同一个包中
• 如果子类与父类在同一个包中，它也继承父类的package-private方法
  2.方法覆盖
• 在子类中的实例方法与在父类中的实例方法有相同的签名和返回类型时，称作覆盖了父类的方法
• 当在子类中覆盖一个父类的方法时，用**@Override**注解符通知编译器在编译期间我想要覆盖的父类的方法
  3.方法覆盖
  如果子类中定义与父类有相同签名类方法，这个方法就隐藏父类中的方法
  4.父类对象与子类对象的转换
  子类对象和父类对象在一定条件下是可以相互转换的
  转换需遵循以下规则：
• 子类对象可以看成是其父类的一个对象
• 父类对象不能当做是其一子类的对象
• 在方法参数中，如果方法参数是父类的对象，在调用方法时可以用其子类作为实际的参数
  如：

class dad
{
     public int add(class dad)
     {
         ...
     }
}
class son
{
     public int addd(class dad)
     {
         ...
     }
}
则可以：
dad my_dad = new dad();
son my_son = new son();
my_dad.add(my_son);

• 如果父类对象引用指向的实际是一个子类对象，那么这个父类对象的引用可以用强制类型转换成子类对象的引用

构造方法继承

1.构造方法继承
子类可以继承父类的构造方法，但继承需遵循下列原则：

• 如果子类没有无参数构造方法，它将继承父类的无参数构造方法作为自己的构造方法
• 如果有自己的无参数构造方法，则在创建对象时先执行父类的无参数构造方法，然后再执行自己的无参数构造方法
• 如果子类在其构造方法中要调用父类的有参数构造方法，则使用super关键字在子类构造方法第一条语句调用，调用格式：super(<参数表>);
  2.设计构造方法

抽象类

1.抽象方法与抽象类
抽象类是被abstract声明的类，它可以包含也可以不包含抽象方法

public abstract class GraphicObject
{
     // declare fields
     .......
     //declare non-abstract methods
     abstract void draw();
     .......
}

抽象方法是一种声明而不用实现的方法
2.声明抽象类和抽象方法
抽象类由abstract修饰，声明与类声明相同，语法格式：

public abstract class 类名 extends 类名 implements 接口
{
    //声明域
    //声明非抽象方法
    //声明抽象方法
}

抽象方法的声明格式：

修饰  abstract  类型  方法名称（[参数表]);
例：public  abstract  void  draw();

3.抽象类的类成员
4.使用抽象类
使用关键字abstract必须遵循如下规则：

• 不能用于构造方法
• 不能用于静态方法和私有方法
• 由abstract修饰的方法必须在子类实现，如果子类没有对抽象方法提供实现，子类仍然要用abstract声明
• 子类不能覆盖超类中的abstract方法

（1）抽象类实现接口

import java.awt.event.*;
public abstract class AbstractMouseListener implements MouseListener//MouseListener接口
{
    public void mousePressed(MouseEvent e)
    {
       //被实现的MouseListener接口方法
       .....
    }
    public void mouseReleased(MouseEvent e)
    {
       //被实现的MouseListener接口方法
       .....
    }
}

（2）抽象类的类成员
抽象类可以包含static修饰的域和方法（即类变量和类方法）
（3）抽象类表示抽象方法
（4）抽象类实现类型隐藏

接口

1.java接口
java语言中接口是像类一样的引用型类型，仅可包含常量、方法签名，嵌套类型
接口不能被实例化，仅能被类或其他接口扩充
定义接口：

//定义接口
public interface OperateCar
{
    //method signatures
    int turn(Direction direct,double radius,double speed);
    int changeLanes(Direction direct,double start,double end);
    int signalTurn(Direction direct,boolean signalOn);
}
//实现接口
public class OperateBMW760i implements OperateCar
{
    public int turn(Direction direct,double radius,double speed)
    {
       .....
    }
    public int changeLanes(Direction direct,double start,double end)
    {
       .....
    }
    public int signalTurn(Direction direct,boolean signalOn)
    {
       .....
    }
}

2.定义接口
接口中的所有方法必须都是抽象的，所以在定义时不用再写abstract关键字
接口的声明方式：

[修饰]  interface  接口名称  extends  接口1，接口2....
{
        /*此为接口体部*/
        public static final 成员变量
        //抽象方法1
        //抽象方法2
        //.....
}

• 接口体部包含所有方法的方法声明，所有的方法声明是隐含public，因此public可以省略
• 所有定义在接口中的常量隐含public、static和final所以不用再另外写了
• 接口一旦定义并使用就不要试图为他再增加新的方法声明。因为这样会使所有实现原有接口的类不能被编译，除非重新修改这些类
  3.实现接口
  格式如下：

[修饰]  class  类名  extends  父类名  implements  接口
{
    ......
}

注意：

• 在定义类时，类声明必须实现接口中的所有方法。否则这个类必须被声明为抽象类
• 通常extends在implements之前
  4.重写接口
  如果迫不得已需要重写接口，可以定义一个新接口并用欲重写的接口作为他的父接口

//原始借口
public interface Dolt
{
   void doSomething(int i,double x);
   int doSomethingElse(String s);
}
//重写的新接口
public interface DoltPlus extends Dolt
{
    boolean didItWork(int i,double x,String s);
}

5.接口与抽象类的差异

• 接口中不实现任何方法，而抽象类有实现的方法
• 类可以实现接口，但它只有一个超级类
• 不相关的类可以实现相同的接口

包

1.包的概念
包由一组类和接口组成，是相关类型的组，提供访问保护和命名空间管理
2.创建包
（1）定义包

• 包语句必须在源文件的第一行
• 每个源文件仅能有一个包语句，并且应用于文件中的所有类型
  语句格式：package 包名称;

（2）命名包

• 包名的所有字符用小写字符
• 包名应避免与包中的类名和接口名冲突

（3）包成员

• 如果在一个源文件放置多个类，仅有一个类可以是public类型的，并且类名称必须与源文件名相同

3.使用包成员
包含在包中的类型称作包成员
从包外面使用包public成员必须通过完全限定名引用包成员，即：包名.成员
例如：
java.io.InputStream in;
java.lang.String name;
或者：
引入包成员，即import 包名字.成员
例如：

import java.io.InputStream;
import java.lang.String;
InputStream  in;
String  name;

或者引入包中所有成员，即：import 包名.*

import java.io.*;
import java.lang.*;
InputStream  in;
String  name;

4.static import语句
有时需要频繁从一个或两个类中访问static final域（常量）和static方法，类名作为前缀名反复出现在代码中
static import语句提供引入常量和静态方法而不用类名作为前缀的途径：import static 包名.成员；
例如：

import static java.lang.Math.*;
double r = cos(PI * theta);

对于外围类的嵌套类，也允许用import引入，即：
import 包名字.*，但需要进行两个步骤

5.管理类文件和源文件

System类、Scanner类和Math类

1.System类

• System类包含一些有用的类字段和方法，它不能被实例化
• System类提供的设施中，有标准输入、标准输出和错误输出流
  
  
  
  2.Scanner类
  
  3.Math类