java学习之路2--面向对象

前言

C语言是面向过程，而java是面向对象，这两者在思想上有一些不同

继承

1. 继承格式：使用extends

class 父类 {
}
 
class 子类 extends 父类 {
}

2. 作用：两个类有共同的属性和方法，可以把共同的属性和方法提取到一个类，然后进行构造父类
3. 继承的种类

单继承：class B->class A
多重继承：class C-->class B-->class C
共同继承一个类的：class B-->class Aclass A

4. 特点

子类拥有父类非 private 的属性、方法。

子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

子类可以用自己的方式实现父类的方法。

5. extends关键词，是单一继承，就是一个子类只能继承一个父类
6. implements关键词，相当于多重继承，就是与接口相结合：interface，继承多个接口在这里插入代码片 7.关键词：

7. super关键词：可以实现对父类成员的访问（方法和属性）
8. this关键词：对象的调用，对象自己的方法的调用
9. final关键词：被final修饰的类，不能被继承，被final修饰的方法不能被重写

重写和重载

1. 重写

对父类的方法进行重新定义方法
class Animal{
   public void move(){
      System.out.println("动物可以移动");
   }
}
 
class Dog extends Animal{
   public void move(){
      System.out.println("狗可以跑和走");
   }
}
 
public class TestDog{
   public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象
 
      a.move();// 执行 Animal 类的方法
 
      b.move();//执行 Dog 类的方法
   }
}

1.被final，private修饰的，不能别重写
2.static修饰的，不能被重写，但是可以被再次声明
3.构造方法不能被重写

2. 重载 参数类型，返回类型，参数个数都可以改变，方法名名字相同

 - 被重载的方法必须改变参数列表(参数个数或类型不一样)；
 - 被重载的方法可以改变返回类型；
 - 被重载的方法可以改变访问修饰符；
 - 被重载的方法可以声明新的或更广的检查异常；
 - 方法能够在同一个类中或者在一个子类中被重载。
 - 无法以返回值类型作为重载函数的区分标准。

多态

1. 重写或者重载（上面有）
2. 定义对象时，父类和子类：

public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 对象调用 show 方法
      show(new Dog());  // 以 Dog 对象调用 show 方法
                
      Animal a = new Cat();  // 向上转型  
      a.eat();               // 调用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下转型  
      c.work();        // 调用的是 Cat 的 work
  }  
            
    public static void show(Animal a)  {
      a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

抽象类

1. 抽象类由 abstract class来定义抽象类，抽象类不能实例化对象（定义对象），但是可以被继承，子类拥有抽象类的成员属性和成员方法。
2. 代码演示：

父类
package java学习练习案例;

public abstract class Employee {
    private String name;
    private String address;
    private int number;
    public Employee(String initialName,String initialAddress,int initialNumber) {
        name = initialName;
        address=initialAddress;
        number=initialNumber;
    }
    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 int getNumber(){
        return number;
    }
    public void setName(String newName){
        name=newName;
    }
    public void setAddress(String newAddress){
        address=newAddress;
    }
    public void setNumber(int newNumber){
        number=newNumber;
    }

}

子类
/* 文件名 : Salary.java */
public class Salary extends Employee
{
   private double salary; //Annual salary
   public Salary(String name, String address, int number, double
      salary)
   {
       super(name, address, number);
       setSalary(salary);
   }
   public void mailCheck()
   {
       System.out.println("Within mailCheck of Salary class ");
       System.out.println("Mailing check to " + getName()
       + " with salary " + salary);
   }
   public double getSalary()
   {
       return salary;
   }
   public void setSalary(double newSalary)
   {
       if(newSalary >= 0.0)
       {
          salary = newSalary;
       }
   }
   public double computePay()
   {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
}

测试类：
/* 文件名 : AbstractDemo.java */
public class AbstractDemo
{
   public static void main(String [] args)
   {
      Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
      Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
 
      System.out.println("Call mailCheck using Salary reference --");
      s.mailCheck();
 
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
    }
}

2. 抽象方法：

父类的抽象方法，只有方法头，没有方法体，方法体由子类来进行重写
一个类包含抽象方法，这个类一定是抽象类
子类一定重写抽象方法。

3. 一些规定：

1. 抽象类不能被实例化(初学者很容易犯的错)，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。

2. 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

3. 抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。

4. 构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。

5. 抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。

封装：

1. 成员属性的封装：使用private封装
2. 使用get或者set方法，对成员属性进行获得和修改
3. 成员方法使用public

/* 文件名: EncapTest.java */
public class EncapTest{
 
   private String name;
   private String idNum;
   private int age;
 
   public int getAge(){
      return age;
   }
 
   public String getName(){
      return name;
   }
 
   public String getIdNum(){
      return idNum;
   }
 
   public void setAge( int newAge){
      age = newAge;
   }
 
   public void setName(String newName){
      name = newName;
   }
 
   public void setIdNum( String newId){
      idNum = newId;
   }
}

接口

1. 接口的声明：

[可见度] interface 接口名称 [extends 其他的接口名] {
        // 声明变量
        // 抽象方法
}
声明变量只能为被final，static修饰的变量。
声明接口和方法时，都不需要abstract关键字来修饰。
接口的方法是公有的。

实例

interface Animal {
   public void eat();
   public void travel();
   
public class MammalInt implements Animal{
 
   public void eat(){
      System.out.println("Mammal eats");
   }
 
   public void travel(){
      System.out.println("Mammal travels");
   } 
 
   public int noOfLegs(){
      return 0;
   }
 
   public static void main(String args[]){
      MammalInt m = new MammalInt();
      m.eat();
      m.travel();
   }
}
}

3. 一些规则：

重写接口中声明的方法时，需要注意以下规则：

类在实现接口的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常。
类在重写方法时要保持一致的方法名，并且应该保持相同或者相兼容的返回值类型。
如果实现接口的类是抽象类，那么就没必要实现该接口的方法。
在实现接口的时候，也要注意一些规则：

一个类可以同时实现多个接口。
一个类只能继承一个类，但是能实现多个接口。
一个接口能继承另一个接口，这和类之间的继承比较相似。（可以多继承，多重继承）