java学习笔记之抽象类和接口

java学习笔记之–抽象类

@()[抽象类|java|super用法|强制转换|abstract|接口]

最近正在学习java，遇到抽象类，看书有些问题还是没有理解，这里通过网上资料详细说明：

• 1 ：[抽象类不能被实例化，实例化的工作应该交由它的子类去完成，它只需要一个引用即可][3]；
• 2 ：[抽象方法必须由子类进行重写][3]；
• 3 ：[抽象类中可以包含具体的方法，当然也可以不包含抽象方法][3]。
• 4 ：[只要包含一个抽象方法的抽象类，该方法必须定义成抽象类，不管是或否还包含其他方法][3]。
• 5 ：[子类中的抽象方法不能与父类的抽象方法同名][3]。
• 6 ：[abstract不能与final并列修饰同一个类][3]；
• 7 ：[abstract 不能与private、static、final或native并列修饰同一个方法][3]。

---

抽象类

抽象类是如果一个类没有足够的信息来描述一个具体的对象，而需要其他具体的类来支撑它，那么这样的类我们称它为抽象类

代码块

• 1 定义一个抽象类

@代码一
package abstractClass;

public abstract class Person //抽象类
{
    /**
     * Person是个抽象类，它除了自己定义抽象方法之外，
     * 还可以自己定义一般方法，getName() 和 抽象方法getDescription()
     */

    public Person(String n)
    {
        name = n;
    }

    public String getName()
    {
        return name;
    }

    public abstract String getDescription();// 这是抽象方法
    private String name;
}

• 2 写一个student类，继承person类，重写getDescription()方法；

@代码二
package abstractClass;

public class Student extends Person {

    private String major;

    public Student(String n,String m){

        super(n);
        major = m;
    }

    @Override
    public String getDescription(){
        return "a student majoring in "+major;
    }
}

• 3 定义Employee部分，重写getDescription()方法

@代码三
package abstractClass;

import java.util.Date;
import java.util.GregorianCalendar;

public class Employee extends Person {

    private double salary;
    private Date hireDay;

    public Employee(String n,double s, int year,int month,int day)
    {
        super(n);
        salary = s;
        GregorianCalendar calendar = new GregorianCalendar(year,month-1,day);
        hireDay = calendar.getTime();
    }

    public double getSalary()
    {
        return salary;
    }

    @Override
    public String getDescription()
    {
        return String.format("an employee with a salary of %.2f",salary);
    }
    public Date getHireDay()
    {
        return hireDay;
    }

    public void reaiseSalary(double byPercent)
    {
        double raise = salary * byPercent/100;
        salary+=raise;
    }

}

• 4 main()函数部分，实例化变量Employee和student部分，对people[0]强制转换，调用其他实例化方法

@代码四
package abstractClass;

public class Persontest {
    /**
     * 这个程序是抽象类的说明
     */
    public static void main(String[] args){
        Person[] people = new Person[2];

        people[0] = new Employee("bruce",5000,1989,10,10);
        people[1] = new Student("harry","compute science");

        for(Person p:people)
            System.out.println(p.getName()+" ,"+p.getDescription());
        //下面定义的就是强制转换的类，把people[0]强制转换成为e，然后进行下一步对e的方法来操作。
        Employee e = (Employee)people[0];

        System.out.println(e.getHireDay());
        System.out.println(e.getSalary());
        System.out.println(e.getDescription());

    }
}

接口

在现实生活中，当我们想起某个用具的时候，往往想到的是该用具的功能性接口。比如手电筒，我们优先想到的是开关和电池没电的时候需要充电，而不是考虑手电筒的内部复杂的电路结构，以及手电筒的价格等其他因素。也就是说，一定程度上，用具的接口等同于用具本身。

接口使用中注意的几个方法

• 1 [接口中不存在实现的方法][3]
• 2 [实现接口的非抽象类必须要实现该接口的所有方法。抽象类可以不用实现][3]
• 3 [在实现多接口的时候一定要避免方法名的重复][3]

代码块

• 1 cup接口定义

interface cup {
    void addWater(int w);
    void drinkWater(int w);
//    void playMusic();
}

• 2 增加一个音乐播放的功能接口

interface MusicPlayer {
    void play();
}

• 3 在类MusicCup中实施接口

public class MusicCup implements cup,MusicPlayer {

    // --------------------------------- 接口函数实现部分 --------------------------------
    public void addWater(int w)
    {
        this.water = this.water + w;
        System.out.println(this.water);

    }

    public void drinkWater(int w)
    {
        this.water = this.water - w;
        System.out.println(this.water);
    }


    public int waterCount()
    {

        return this.water;
    }

    public void play()
    {
        System.out.println("快使用双节棍嘿嘿哈嘿^_^");
    }
    //------------------------------------------------------------------------------------


    //main 函数
    public static void main(String args[]){

        MusicCup a_cup = new MusicCup();
        a_cup.addWater(10);
        a_cup.drinkWater(9);
        a_cup.play();
    }



    private int water=0;
}

/**
 *
 * public water 只要一改变，就都会改变，第一次计算是10，后来用10来接着计算后面的数值
 * 接口的实现，可以用很多个接口，然后是implements
 *
 * 定义的接口是在cup和MusicPlay函数中，它是接口的定义。
 *
 * 接口是封装的一种延伸，就是当我们用手电筒的时候，不需要的或者是内部的电路结构一般
 * 是要封装起来的，接口就是从类的具体定义中剥离出来，定义杯子，能加水，喝水，就是接口，接口一定程度
 * 等同于用具本身，内部细节的思考过程被摒弃。我们一般会定义一个接口的原型，然后告诉具体原型的使用方法，
 * 凡是定义的原型，必须在使用方法中具体实现。在实施接口中可以出现接口中没有的函数，比如noOfLegs函数。
 * 这里的接口很像C++里面的函数原型一样

 */

接口与抽象类的区别

抽象类方式，可以有任意范围的成员数据，同时也可以有自己的非抽象方法。但是接口，仅仅只能有静态、不能修改的成员数据，实现接口的非抽象类必须要实现该接口的所有方法。