java基础（6）- 面向对象（3）

注 ： 参考自https://mp.weixin.qq.com/s/MrrN7BDcKMu8SCKs6zij_g

6.1abstract抽象类

6.2接口

6.3问题总结；值传参，对象作为参数时的值传参

6.1abstract抽象类

一、什么是抽象类

由abstract修饰的方法叫抽象方法；由abstract修饰的类叫抽象类。抽象的类无法进行实例化，因为他不是具体存在的类，或者说这样的类还不够完善，不能直接使用new关键字调用其构造器生成该类的对象。我们可以使用abstract定义一个抽象类和抽象方法，示例代码如下：

abstract class 类名{abstract int 方法名(int x,int y);}

抽象的方法没有方法体。需要注意的是在抽象类中既可以有抽象方法，也可以有普通方法，注意抽象方法是没有方法体的（也就是方法后面是没有大括号的）。凡是继承这个抽象类的实体子类，都必须要实现这个抽象方法。

我们总结一下抽象类的特点：

（1）抽象类不能被实例化

（2）构造方法 和 static 方法不能是抽象的

（3）父类的抽象方法往往在子类中实现

（4）抽象类可以具有指向子类对象的对象引用

二、抽象类的例子

我们先来看看要完成的实际例子：

1、定义抽象类员工Employee,

（a）保护字段：姓名name,性别gender，年龄age等基本属性。

（b）定义抽象方法函数getsalary()表示领工资的操作

（c）定义普通函数whoami()输出 ：我是+姓名

（d）拥有（姓名name,性别gender）参数的构造函数

定义一个经理类Manager 派生于员工；

（a）除了有员工等基本属性外，还有岗位级别 gree私有属性

（b）经理领7000元工资，打印并输出工资。

（c）重写父类的whoami(),调用父类的whoami()方法，再输出：我是一名经理。

定义一个会计类Accounting,派生于员工类；

（a）除了有员工等基本属性外，还有会计等级 rating私有属性

（b）会计领3000元工资，打印并输出工资。

（c）重写父类的whoami(),调用父类的whoami()方法，再输出：我是一名会计。

/**
 * 定义类员工Employee,
 */
public abstract class Employee {
    protected String name;
    protected boolean gender;
    protected int age;
    public Employee(String name,boolean gender){
        this.name=name;
        this.gender=gender;
    }
    /**
    * 表示领工资的操作
    */
    public abstract void getsalary();
    public void whoami(){
        System.out.println("我是"+name);
    }
}

我们新建一个经理类Manager，继承Employee类，这时候Eclipse就提示我们必须要重写抽象方法getsalary。示例代码如下：

/**
 * 经理类
 */
public class Manager extends Employee{
    private String gree;
    
    public Manager(String name,boolean gender){
        super(name,gender);
    }
    //重写父类的抽象方法
    public void getsalary(){
        System.out.println("经理领7000元工资");
    }

    public void whoami(){
        super.whoami();//显示调用父类的方法
        System.out.println("我是经理");
    }
}

接下来是会计类。和上面的经理类差不多了。

/**
 * 会计
 */
public class Accounting extends Employee {
    private int rating;
    public Accounting(String name, boolean gender) {
        super(name, gender);
    }
    @Override
    public void getsalary() {
        System.out.println("会计发3000工资");
    }
    public void whoami() {
        super.whoami();// 显示调用父类的方法
        System.out.println("我是会计");
    }
}

6.2接口

接口

一、什么是接口

接口就是一个规范，类似于硬件上面的接口，在电脑主板上的PCI插槽的规范就类似于Java接口，只要是遵循PCI接口的卡，不过是什么牌子的都可以插入到PCI插槽中。所以接口就是一个规范。接口就是某个事物对外提供的一些功能的说明。我们还可以利用接口实现多态功能，同时接口也弥补了Java单一继承的弱点，也就是类可以实现多个接口。

我们使用interface关键字定义接口，一般使用接口声明方法或常量，接口中的方法只能是声明，不能是具体的实现，这一点和抽象类是不一样的。接口是更高级别的抽象。接口的定义格式是

public interface 接口名称{//可以定义常量//方法只有方法声明,而且是公共的。public void 方法名称();...}//类要实现接口，只需要使用implements关键字，实现类必须要实现接口中的所有的方法public class 实现类名 implements 接口{//实现接口的方法}

二、接口的应用

定义一个接口非常简单，当然其实要设计一个好的接口并不是很简单，你必须要想好这个接口有什么常量和方法。但是技术却非常简单，示例代码如下：

// 定义方法的接口
public interface Myinterface {
  // 定义程序使用的常量的接口，接口中只能有常量。
  public static final double price = 1450.00;
  public static final int counter = 5;
  //接口中所有的方法都没有方法体。
  public void add(int x, int y);
  public void volume(int x,int y, int z);
}

实现接口也没有什么难度，代码如下：

                           //实现     接口
public class MyImple implements Myinterface {
    @Override
        public void add(int x, int y) {
    }
    @Override
        public void volume(int x, int y, int z) {
    }
}

一个类是可以实现多个接口，因为java是单继承的，这点接口可以弥补。我们可以再定义一个接口

public interface MyInterface2 {
     public void countpp();
}

修改上面的实现类，要实现多个接口，可以使用逗号隔开，当然所有的接口的方法都要实现。

                           //实现       接口1,接口2
public class MyImple implements Myinterface ,MyInterface2{
    @Override
    public void add(int x, int y) {
    }
    @Override
    public void volume(int x, int y, int z) {
    }
    @Override
    public void countpp() {
    }
}

三、接口和抽象类有什么区别

abstract class和interface是Java语言中对于抽象类定义进行支持的两种机制，abstract class和interface之间在对于抽象类定义的支持方面具有很大的相似性，甚至可以相互替换，因此很多开发者在进行抽象类定义时对于abstract class和interface的选择显得比较随意。其实，两者之间还是有很大的区别的

1、抽象类里面可以有非抽象方法。但接口里只能有抽象方法，接口体现的是一种规范，抽象类体现的是模板式设计。

2、接口（interface）是抽像类的变体。在接口中，所有方法都是抽像的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽像的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对像上调用接口的方法。由于有抽像类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口

3、接口里不可以定义静态方法，抽象类里可以。接口里的变量全部为静态常量，抽象类里可以有普通变量。

4.接口里不可以有构造函数和初始化块，抽象类里可以有。

5.一个类可以实现多个接口，但只能继承一个抽象类。

6.3问题总结；值传参，对象作为参数时的值传参

问题一、is-a的关系

我们前面讲过面向对象思想简单概括起来就是三个：封装(Encapsulation)、继承(Inheritance)和多态(Polymorphism)。这个思想大家应该作为一个整体去理解，而不是单独理解，我们继承其实也是一种封装的思想，而继承也是可以支持多态的，这里我们讲讲多态的实现。下面我们就以在abstract抽象类章节中使用过的抽象类Employee，经理类Manager，会计类Accounting来讲解一下多态的使用。

我们在建立一个类，代码如下：

/**
 * 操作类
 */
public class Cao {
    //以抽象类作为参数，但是在调用这个方法时，必须要传入的是抽象类Employee的实现类
    public void test(Employee employee){
        employee.getsalary();
    }
}

到底是给经理类还是给会计发工资呢。必须在Run类中才能知道。在以后学了发射等高级java时，会再次使用多态的技术。Run类的实现代码如下：

public class Run {
    public static void main(String[] args) {
        //这个员工既可以是
        //Employee employee=new Manager();
        Employee employee=new Accounting();
        Cao cao=new Cao();
        cao.test(employee);
    }
}

问题二、值传参，对象作为参数时的值传参

值传参和传指针在C语言里面有比较多的讨论，如果你以前学习过C语言，那么你也可以把对象理解为是一个指针，对象多有的属性的数据和方法都是由这个指针指向而已。我们先讲讲值传参吧！首先我们先看看下面这段程序。

public class Test2 {
    //值传参
    public void op(int a,int b){
        int c;
        c=a;
        a=b;
        b=c;
        System.out.println("a="+a);
        System.out.println("b="+b);
    }
    
    public static void main(String[] args) {
        int x=100,y=-1;
        
        Test2 test2=new Test2();
        test2.op(x, y);
        
        System.out.println("x="+x);//输出还是 100
        System.out.println("y="+y);//输出还是 -1    
    }
}

在这段程序中，我们想要实现一个方法，功能是交换两个数的值，但是在程序中调用这个方法后，在方法中的a和b的值已经交换了，但是x和y这两个变量的值并没有改变，这是因为程序在方法传参时使用的是值传参方式。如图所示：

那么我修改一下这个程序

public class Test3 {
    
    public int a;
    public int b;
    
    public void op(Test3 tt){
        int c;
        c=tt.a;
        tt.a=tt.b;
        tt.b=c;
    }
    
    public static void main(String[] args) {
        Test3 test3=new Test3();
        test3.a=100;
        test3.b=-1;
        
        test3.op(test3);
        
        System.out.println("a="+test3.a);//输出-1
        System.out.println("b="+test3.b);//输出100

    }

}

在这里我们修改了这个方法，把变量a和b作为类的属性封装起来，同时op方法也是传递的是一个对象。这时候输出对象a的值就已经加了100。为什么会这样了？其实我们还是使用值传参的。不过这个值是一个对象，而对象是指向它的数据。所以我们把对象tt的值改变后，对象test对应的值也会发生改变。

如果你还不明白，你可以在main方法中再测试一下代码：

Test3 abc=new Test3();
abc.a=100;
        
Test3 efg;
efg=abc;// 把对象abc的值赋给efg，这样两个对象指向的是同一数据
efg.a=-12;//通过efg对象修改之后
System.out.println(abc.a);//再用abc对象访问时候，数据也发生了变化