Java面向对象

比较适用于Java复习

面向对象)

1 继承

• 继承中最常用的关键字是extends和implements
• 类继承interface(接口)只能用implements，不能用extends.
• 可以使用 instanceof 运算符来检验子类对象是否是父类的一个实例
• Java中类的继承是单一继承（继承基本类和抽象类），也就是说，一个子类只能拥有一个父类，但是我们可以用接口来实现（多继承接口来实现）
  如：

public class Cat extends Animal implements Aniaml1, Aniaml2{
}

1.1 IS-A关系

IS-A指一个对象是另一个对象的一个分类

实例

public interface Animal{
}
public class People implements Animal{
}
public class Children extends People{

   public static void main(String args[]){

      People p = new People();
      Children c = new Children();

      System.out.println(p instanceof Animal);
      System.out.println(c instanceof People);
      System.out.println(c instanceof Animal);
   }
}

结果为：

true
true
true

IS-A关系：

• People IS-A Animal
• Children IS-A People
• Children IS-A Animal

1.2 HAS-A关系

HAS-A代表类和它的成员之间的从属关系。这有助于代码的重用和减少代码的错误。

public class Vehicle{}
public class Speed{}
public class Van extends Vehicle{
	private Speed sp;
} 

Van类和Speed类是HAS-A关系(Van有一个Speed)，这样就不用将Speed类的全部代码粘贴到Van类中了，并且Speed类也可以重复利用于多个应用程序。
在面向对象特性中，用户不必担心类的内部怎样实现。

Van类将实现的细节对用户隐藏起来，因此，用户只需要知道怎样调用Van类来完成某一功能，而不必知道Van类是自己来做还是调用其他类来做这些工作。

2 重写与重载

2.1 重写

重写是指 子类对父类可以访问的方法的具体实现 重新编写。
返回值和形参都不能改变，即外壳不变，大括号里的内容重写。
如：
重写规则：

• 参数列表和返回类型完全相同
• 子类方法的访问权限必须大于或等于父类方法的访问权限
• 父类的成员方法只能被它的子类重写
• 声明为final的方法不能被重写；声明为static的方法不能被重写，但是能够被再次声明
• 构造方法不能被重写
• 如果不能继承一个方法，则不能重写这个方法
• 重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常

Super关键字
当需要在子类中调用父类的被重写方法时，要使用super关键字。

class Animal{

   public void move(){
      System.out.println("动物可以移动");
   }
}

class Dog extends Animal{

   public void move(){
      super.move(); // 应用super类的方法
      System.out.println("狗可以跑和走");
   }
}

public class TestDog{

   public static void main(String args[]){

      Animal b = new Dog(); //
      b.move(); //执行 Dog类的方法

   }
}

运行结果：

动物可以移动
狗可以跑和走

2.2 重载

重载(overloading) 是在一个类里面，方法名相同，而参数不同。
返回类型和访问修饰符？可以相同也可以不同。

每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。
只能重载构造函数。
重载规则：

• 被重载的方法必须改变参数列表；
• 被重载的方法可以改变返回类型；
• 被重载的方法可以改变访问修饰符；
• 被重载的方法可以声明新的或更广的检查异常；
• 方法能够在同一个类中或者在一个子类中被重载。

public class Overloading {
 
	public int test(){
		System.out.println("test1");
		return 1;
	}
 
	public void test(int a){
		System.out.println("test2");
	}	
 
	//以下两个参数类型顺序不同
	public String test(int a,String s){
		System.out.println("test3");
		return "returntest3";
	}	
 
	public String test(String s,int a){
		System.out.println("test4");
		return "returntest4";
	}	
 
	public static void main(String[] args){
		Overloading o = new Overloading();
		System.out.println(o.test());
		o.test(1);
		System.out.println(o.test(1,"test3"));
		System.out.println(o.test("test4",1));
	}

3 抽象

3.1 抽象方法

抽象方法只包含一个方法名，而没有方法体，后面直接跟一个分号，而不是花括号。
继承抽象方法的子类必须重写该方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该抽象方法，否则，从最初的父类到最终的子类都不能用来实例化对象。

3.2 抽象类

含有抽象方法的类称为抽象类。抽象类不能实例化对象。
抽象类当中可以存在数据成员和非抽象的方法

public abstract class Employee
{
   private String name;
   private String address;
   private int number;
   
   public abstract double computePay();
   //抽象方法   
   //其余代码
}

4 接口

接口interface **并不是类，**只是编写接口的方式和类很相似。除非实现接口的类是抽象类，否则该类要实现接口中的所有方法。

• 接口不能包含成员变量，除了static和final变量
• 接口支持多重继承，即一个类可以同时实现多个接口
• 一个接口能继承另一个接口，使用extends
• 接口不是被类继承了，而是要被类实现,使用implements
• 接口中所有的方法必须是抽象方法且是公有的，接口不能实例化对象

public interface People
{
      public void eat();
      public void exercise();   
}

public class Students implements People
{
     public void eat()
     {
           System.out.println("eat");
     }
     public void exercise()
     {
           System.out.println("exercise");
     }
     public void study()
     {
           System.out.println("study");
     }
}

5 包

一个包（package）可以定义为一组相互联系的类型（类、接口、枚举和注释），为这些类型提供访问保护和命名空间管理的功能。
如：

• java.lang-打包基础的类
• java.io-包含输入输出功能的函数

包的作用

1. 把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用
2. 同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。
3. 包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类
4. 为了能够使用某一个包的成员，我们需要在 Java 程序中明确导入该包，使用"import"语句可完成此功能