任务实训15--抽象方法和抽象类的应用

abstract在java中用法(一)Abstract在Java中在Java中，abstract是一个关键字，用于定义抽象类和抽象方法。

抽象类是一种特殊的类，不能被实例化，只能用作其他类的基类。

抽象方法是一种没有具体实现的方法，只有方法声明，没有方法体。

下面将详细讲解abstract在Java中的用法。

抽象类抽象类是一种用abstract关键字修饰的类。

它不能被实例化，只能作为父类被继承。

抽象类的主要作用是定义子类需要实现的一组方法，子类必须实现这些方法才能被实例化。

定义抽象类的语法如下：abstract class AbstractClass {// 抽象方法public abstract void abstractMethod();// 普通方法public void normalMethod() {// 方法实现}}抽象类可以包含抽象方法和普通方法。

抽象方法用abstract关键字修饰，没有方法体；普通方法有方法体。

抽象类可以包含普通成员变量和静态成员变量，也可以包含普通方法和静态方法。

但是不能创建抽象类的实例。

抽象方法抽象方法是一种没有具体实现的方法，只有方法声明。

抽象方法用abstract关键字修饰，没有方法体。

抽象方法必须在抽象类中声明，子类必须实现这些抽象方法才能被实例化。

定义抽象方法的语法如下：abstract void abstractMethod();抽象方法也可以包含参数和返回值，用于定义子类必须实现的方法签名。

子类继承抽象类后，必须实现抽象方法，否则子类也必须声明为抽象类。

继承抽象类子类继承抽象类后，必须实现抽象类中的所有抽象方法才能被实例化。

子类可以通过覆盖抽象方法来实现具体的功能。

如果子类不想实现某个抽象方法，那么子类也必须声明为抽象类。

继承抽象类的语法如下：class ConcreteClass extends AbstractClass {// 实现抽象方法public void abstractMethod() {// 方法实现}// 覆盖普通方法public void normalMethod() {// 方法实现}}注意，如果一个类继承了抽象类，但没有实现抽象方法，则该类必须声明为抽象类。

实验-抽象类和接⼝学⽣实验报告课程：实验指导教师：系别：班级：实验⽇期：年⽉⽇实验地点：姓名：学号：⼀、实验名称：抽象类和接⼝实验概述：【实验⽬的及要求】1 ⼦类的继承性2⼦类对象的创建过程3成员变量的继承和隐藏4⽅法的继承和重写【实验环境】（使⽤的软件）Eclipse实验内容：【实验过程】（实验步骤、记录、数据、分析）实验内容：⼀、有⼀个abstract类，类名为Employee。

Employee的⼦类有YearWorker，MonthWorker 和WeekWorker。

YearWorker对象按年领取薪⽔，MonthWorker对象按⽉领取薪⽔，WeekWorker对象按周领取薪⽔。

Employee类有⼀个抽象⽅法：public abstract double earnings( );⼦类必须重写⽗类的earnings⽅法，给出各⾃领取报酬的具体⽅式。

有⼀个Company类，该类⽤employee数组作为成员，employee数组的成员可以是YearWorker对象的上转型对象、MonthWorker对象的上转型对象或WeekWorker对象的上转型对象。

程序能够输出Company对象⼀年需要⽀付的薪⽔总额。

程序模板按模板要求，将【代码1】～【代码4】替换为Java程序代码。

HardWork.javaabstract class Employee{public abstract double earnings( );}class YearWorker extends Employee{【代码1】// 重写earnings( )⽅法}class MonthWorker extends Employee{【代码2】// 重写earnings( )⽅法}class WeekWorker extends Employee{【代码3】// 重写earnings( )⽅法}class Company{Employee[ ] employee;double salaries=0;Company(Employee[ ] employee){this.employee=employee;}public double salariesPay( ){salaries=0;【代码4】// 计算salariesreturn salaries;}}public class HardWork{public static void main(String args[ ]){Employee[ ] employee=new Employee[20]; for(int i=0;i{if(i%3==0)employee[i]=new WeekWorker( );else if(i%3==1)employee[i]=new MonthWorker( );else if(i%3==2)employee[i]=new YearWorker( );}Company company=new Company(employee);System.out.println("公司年⼯资总额:"+company.salariesPay( ) );}}问题：1、⼦类YearWorker如果不重写⽗类的earnings( )⽅法，程序编译时会提⽰怎样的错误？⼆、有⼀个ComputeTotalSales接⼝，该接⼝中有⼀个⽅法：public double totalSalesByYear( );有三个实现该接⼝的类：Television、Computer和Mobile。

Python之抽象类、抽象⽅法抽象类中只能有抽象⽅法，⼦类继承抽象类时，不能通过实例化使⽤其抽象⽅法，必须实现该⽅法。

Python2class CopyBase(object):def save(self):raise NotImplementedErrorclass CopyPaper(CopyBase):def__init__(self):passdef save(self):print("copy paper")class CopyQuestion(CopyBase):def__init__(self):passcopy_paper = CopyPaper()copy_paper.save()copy_question = CopyQuestion()copy_question.save()result:copy paperTraceback (most recent call last):copy_question.save()raise NotImplementedErrorNotImplementedError这⾥以NotImplementedError的形式实现了抽象类和抽象⽅法，如果⼦类不实现该⽅法会抛出异常Python3在Python3中引⼊了abc模块，通过@abc.abstractmethod可以更加简洁地使⽤抽象类，抽象⽅法。

import abcclass CopyBase(metaclass=abc.ABCMeta):@abc.abstractmethoddef save(self):passclass CopyPaper(CopyBase):def__init__(self):passdef save(self):print("copy paper")class CopyQuestion(CopyBase):def__init__(self):passcopy_paper = CopyPaper()copy_paper.save()copy_question = CopyQuestion()copy_question.save()result:copy paperTraceback (most recent call last):copy_question = CopyQuestion()TypeError: Can't instantiate abstract class CopyQuestion with abstract methods save从abc模块引⼊类abstractmethod和类ABCMeta，⾃定义的CopyBase类继承抽象类ABCMeta，在类CopyBase中定义save⽅法，添加装饰器abcstractmethod，CopyPaper类和CopyQuestion继承CopyBase类，分别实例化CopyPaper和CopyQuestion，CopyQuestion类没有实现save⽅法，因此会抛出异常。

抽象类和抽象方法一、定义：java中可以定义的一些不含方法体的方法，它的方法体的实现交给该类的子类根据自己的情况去实现，这就是抽象方法。

包含抽象方法的类就叫做抽象类。

一个抽象类可以有一个或多个抽象方法。

二、抽象规则：1、抽象类和方法必须用abstract来修饰；2、抽象类不能被实例化；3、抽象方法只需声明，无需实现，抽象方法一定调用子类重写后的非抽象的方法；4、抽象类有构造但不能被调用；5、含有抽象方法的类必须声明为抽象类，抽象类的子类必须覆盖所有的抽象方法后才能被实例化，否则这个类还是个抽象类。

注意：抽象方法不能为private的，因为抽象方法没有具体实现，需要在子类中继承并重写来实现具体实现。

抽象方法必须重写实现其具体的功能。

【TestAbstract.java】package day7am;public abstract class TestAbstract {public abstract void test();//含有抽象方法的类一定是抽象类。

public static void main(String[] args) {}}三、抽象方法的继承与实现当某类继承抽象类时，如果其本身不是抽象类时，则必须实现所继承抽象类中的抽象方法。

如，具有启动(startup)方法的抽象车辆类Car，其每中子类都必须实现其自己的、专属于某种类型车辆的具体启动(startup)方法,下边例子就说明了。

【TestAbstract.java】package Pra;//定义抽象类Carabstract class Car{//定义抽象方法startUppublic abstract void startUp();}//定义抽象类Audi并使该类继承自Carabstract class Audi extends Car{//定义抽象方法turbopublic abstract void turbo();}//定义非抽象类Audi_A6继承自Audiclass Audi_A6 extends Audi{//实现startUp方法public void startUp(){System.out.println("调用了奥迪A6的启动功能！！！");}//实现turbo方法public void turbo(){System.out.println("调用了奥迪A6的加速功能！！！");}}//定义非抽象类Audi_A8继承自Audiclass Audi_A8 extends Audi{//实现startUp方法public void startUp(){System.out.println("调用了奥迪A8的启动功能！！！");}//实现turbo方法public void turbo(){System.out.println("调用了奥迪A8的加速功能！！！");}}public class TestAbstract{public static void main(String[] args){//创建Audi_A6对象并使该类引用a6指向该对象Audi_A6 a6=new Audi_A6();//调用Audi_A6对象中的方法a6.startUp();a6.turbo();//创建Audi_A8对象并使该类引用a8指向该对象Audi_A8 a8=new Audi_A8();//调用Audi_A8对象中的方法a8.startUp();a8.turbo();}}程序运行结果：-----------------------------调用了奥迪A6的启动功能！！！调用了奥迪A6的加速功能！！！调用了奥迪A8的启动功能！！！调用了奥迪A8的加速功能！！！-----------------------------上面的例子里定义了4个类，其中Car和Audi为抽象类，他们分别代表轿车和奥迪轿车，故不适具体类，因为轿车和奥迪轿车还有很多子类。

抽象类的使用实验报告计算机0903班胡笑梅学号：********抽象类的使用一、实验目的（1）.在Visual C++6.0的开发环境下定义抽象类，并进一步派生最终形成一个类族。

二、实验任务使用Visual C++建立标准C++程序。

编写一个程序计算正方形、球体和圆柱体的表面积和体积。

三、实验步骤1.启动Visual C++6.0开发环境。

从“开始”菜单里选择“程序”|Microsoft Visual Studio 6.0 | Microsoft Visual C++ 6.0 ，显示Visual C++ 6.0开发环境主窗口。

2.创建一个项目。

单击File菜单中的New选项，进行新建。

选择Win32控制台应用程序。

在文本框里输入项目名称“lab1”，单击ok按钮。

3.建立C++源程序文件。

4.编辑C++源程序文件内容。

5.程序源代码为：#include<iostream>using namespace std;class CCt //定义抽象类CContaineer{protected:float radius; //公共的数据成员radiusdouble area,volume; //表面积area,体积volumepublic：virtual void Area()=0; //求表面积的纯虚函数virtual void V olume()=0; //求体积的纯虚函数CCt(float a,double b,double c) {radius=a;area=b;volume=c;} //基类的构造函数};class Square:public CCt //派生类Square{public:Square(float a,double b,double c): CCt (a,b,c) { }void Area() //虚函数Area() {area=6*radius*radius;cout<<"Square's area="<<area<<endl;}void V olume() //虚函数V olume (){volume=radius*radius*radius;cout<<" Square's volume="<<volume<<endl;}};class circle:public CCt //派生类circle{public:circle(float a,double b,double c): CCt (a,b,c){} //派生类circle构造函数void Area(){area=4*3.14*radius*radius;cout<<"circle's area="<<area<<endl;}void V olume(){volume=3.14*radius*radius*radius*4/3;cout<<" circle's volume="<<volume<<endl;}};class CCtlinder:public CCt//派生类CCtlinder{float high;public:CCtlinder(float h,float r,double a,double v): CCt (r,a,v) {high=h;}void Area() //派生类CCtlinder的虚函数定义{area=2*3.14*radius*radius+2*3.14*radius*high;cout<<" CCt linder's area="<<area<<endl;}void V olume(){volume=3.14*radius*radius*high;cout<<" CCt 's volume="<<volume<<endl;}};void Areafun(CCt *p)//根据p所指向的对象不同，调用不同的派生类Area{p->Area();}void V olumefun(CCt *p) //根据p所指向的对象不同，调用不同的派生类V olume{p->V olume();}void main(){Square r1(5,0,0);// Square的对象r1circle c1(8,0,0); // circle的对象c1CCtlinder cc2(2,14,0,0); // CCt linde的对象cc2Areafun(&r1);//调用的将是派生类Square的Area虚函数V olumefun(&r1);// 调用的将是派生类Square的V olume虚函数Areafun(&c1);V olumefun(&c1);Areafun(&cc2);V olumefun(&cc2);}6.程序运行结果四、实验总结通过实验进一步熟练的使用VC。

Java抽象类、抽象⽅法详解⽬录1. 概述类⽤于描述现实⽣活中⼀类事物。

类中有属性、⽅法等成员。

⽗类中的⽅法，被它的⼦类们重写，⼦类各⾃的实现都不尽相同。

那么⽗类的⽅法声明和⽅法主体，只有声明还有意义，⽽⽅法主体则没有存在的意义了。

某种情况下，⽗类只能知道⼦类应该具备⼀个怎样的⽅法，但是不能够明确知道如何实现该⽅法。

只能在⼦类中才能确定如何去实现⽅法体。

例如：所有⼏何图形都应该具备⼀个计算⾯积的⽅法。

但是不同的⼏何图形计算⾯积的⽅式不同。

我们把没有⽅法主体的⽅法称为抽象⽅法。

Java语法规定，包含抽象⽅法的类就是抽象类。

2. 抽象⽅法抽象⽅法：只有⽅法的声明，没有⽅法体，以分号 ; 结尾，使⽤abstract关键字修饰定义格式：修饰符 abstract 返回值类型⽅法名(参数列表);代码举例：public abstract void run();抽象⽅法不能⽤private、final、static、native修饰3. 抽象类抽象类：包含抽象⽅法的类。

如果⼀个类包含抽象⽅法，那么该类必须是抽象类，使⽤abstract关键字修饰定义格式：public abstract class 类名 {//抽象类中可以包含变量、常量，抽象⽅法，⾮抽象⽅法}代码举例：public abstract class Person {public abstract void work()；}抽象类的使⽤抽象类不能实例化，不能直接创建对象。

抽象类是⽤来被继承的，继承抽象类的⼦类必须重写⽗类所有的抽象⽅法。

否则，该⼦类也必须声明为抽象类，使⽤abstract关键字修饰抽象类也是类，因此原来类中可以有的成员，抽象类都可以有，那么抽象类不能直接创建对象，为什么还有构造器呢？供⼦类调⽤，⼦类创建对象时，需要为从⽗类继承的属性初始化。

抽象类不能使⽤final修饰public class Teacher extends Person {public void work() {System.out.println("讲课");}}public class AbstractClassTest {public static void main(String[] args) {// 创建⼦类对象Teacher t = new Teacher();// 调⽤run⽅法t.work();}}输出结果：讲课此时的⽅法重写，是⼦类对⽗类抽象⽅法的完成实现，我们将这种⽅法重写的操作，叫做实现⽅法。

抽象类、抽象⽅法的定义及实现package day_15;/*** 定义⼀个平⾯图形抽象类*/public abstract class PlaneFigure {public abstract double getArea(); //定义得到⾯积的抽象⽅法public abstract double getPerimeter(); //定义得到周长的抽象⽅法}package day_15;//定义⼀个矩形类public class Rectangle extends PlaneFigure {private double wide;private double length;public Rectangle(){}public Rectangle(double wide, double length) {this.wide = wide;this.length = length;}public double getArea(){ //重写得到⾯积的抽象⽅法return wide*length;}public double getPerimeter(){ //重写得到周长的抽象⽅法return 2*(wide+length);}}package day_15;//定义⼀个圆类public class Circle extends PlaneFigure{private double r;private static final double PI=3.14;public Circle(){}public Circle(double r) {this.r = r;}@Overridepublic double getArea() { //return PI*r*r;}@Overridepublic double getPerimeter() {return 2*PI*r;}}package day_15;public class Test {public static void main(String[] args) {Circle circle=new Circle(3);print(circle);Rectangle rectangle=new Rectangle(3,4);print(rectangle);}public static void print(PlaneFigure planeFigure){ //定义静态⽅法System.out.println("当前平⾯图形的信息:");System.out.println("\t⾯积:"+planeFigure.getArea());System.out.println("\t周长:"+planeFigure.getPerimeter());}}。

抽象⽅法和抽象类抽象类和抽象⽅法1、抽象类 ( Abstract Class )关键字：abstract从形式上看抽象类是由abstract修饰的 Java 类专门为继承体系顶端设计的类通常设计为抽象类抽象类不能被实例化不能通过 new 关键字直接创建抽象类的类型的实例但是可以创建其⼦类的实例抽象类中可以有字段、⽅法、构造⽅法、代码块、内部类特点：1、抽象类可以继承抽象类具体类可以继承抽象类抽象类可以继承具体类2、抽象⽅法是由 abstract 修饰的、没有⽅法体的⽅法3、有抽象⽅法的类必须是抽象类4、如果具体类继承了抽象类，则必须实现抽象类中的所有⽅法2、抽象⽅法如果某个⽅法在声明时⽆法确定其实现细节，则可以省略其实现过程，直接以分号结束如果某个⽅法省略了实现过程连 { } 都省略了此时需要为该⽅法增加关键字 abstract 表⽰该⽅法时抽象的抽象⽅法就是由 abstract 修饰的没有⽅法体的⽅法含有抽象⽅法的类必须就是抽象类但是有抽象类不⼀定有抽象⽅法3、⽰例Human 类package abstractclass;import java.util.Objects;/** 1、抽象类与具体类的区别是抽象类不可以实例化* 2、抽象类不⼀定要有抽象⽅法为了让某个类不能被实例化也可以将该类设计为抽象类** */public abstract class Human extends Object { // 抽象类可以继承实体类protected String name;static {System.out.println("Human:类初始化块");}{System.out.println("Human:实例初始化块");}public Human() {System.out.println("Human()");}public Human(String name) { = name;System.out.println("Human(String)");}public void show() {System.out.println();}public static void main(String[] args) {Human h = null;// h = new Human(); // 【错误】 Human 类是抽象的⽆法实例化}}Sinaean 类有⼀个抽象⽅法 eatpackage abstractclass;/*** 1、抽象类可以继承抽象类具体类可以继承抽象类抽象类可以继承具体类* 2、抽象⽅法是由 abstract 修饰的、没有⽅法体的⽅法* 3、有抽象⽅法的类必须是抽象类* */public abstract class Sinaean extends Human {// 声明⼀个抽象⽅法public abstract void eat(String foodName); // 没有⽅法体、由 abstract 修饰符修饰 }Han 类package abstractclass;/*** 1、如果具体类继承了抽象类，则必须实现抽象类中的所有⽅法*** */public class Han extends Sinaean {@Overridepublic void eat(String foodName) { // 如果有⽅法体就⼀定不能有 abstract 修饰符 System.out.println("在中国汉族⼈基本都使⽤筷⼦吃" + foodName );}public static void main(String[] args) {Han h = new Han(); = "⽕锅";h.eat("⽕锅");}}。

接⼝和抽象类的使⽤，实现公司员⼯⼯资发放 接⼝与抽象类很相似，都可以实现类的多态，不过如果要在组件的所有实现间提供通⽤的已实现的功能，则使⽤抽象类。

抽象类可以提供已实现的成员。

因此，可以⽤抽象类确保特定数量的相同功能，抽象类允许部分实现类，⽽接⼝不包含任何成员的实现。

抽象类主要应⽤与关系密切的对象，⽽接⼝最适合为不相关的类提供通⽤功能。

下⾯我们就⽤抽象类和接⼝实现⼀下简单的部门⼯资发放问题。

⾸先先说⼀下需求分析，如下所⽰： /**某公司有多个部门和职位，不同类型员⼯之间九三⼯资⽅法不同*经理：固定⽉薪+奖⾦* 销售员;固定⽉薪+销售提成（⽉薪+销售额*提成率）*⼯⼈：固定⽉薪+加班费*员⼯⼯资需要缴纳个⼈所得税* <2000 ⽆* >=2000||<=2500 所得税 5%* >2500||<=4000 所得税 >=2000||<=2500 5% &&>2500 10%* >4000 所得税 >=2000||<2500 5% &&>2500<=4000 10% >4000 15%* ＨＲ发放薪⽔*/ 明⽩了需求之后我们就开始写⼀个接⼝了，代码如下1///<summary>2///薪⽔接⼝3///</summary>4interface ISalarySystem5 {6decimal Earnings();//计算薪⽔78string SelfInform();//显⽰员⼯信息9 }然后我们就写⼀个抽象类，⽤来实现提供的⼀组成员如name ，salary，enterdate，所得税的计算⽅法等。

提供抽象成员的Type属性。

⽬的是为了提供通⽤不变的⼀些功能。

代码如下:1///<summary>2///从业员⼯抽象类3///</summary>4public abstract class Employee5 {6private string name;7private decimal salary;8private DateTime entryadte;910public Employee()11 {12//13 }1415public Employee(string name, decimal salary, int year, int month, int day)16 { = name;18this.Salary = salary;19 Entryadte = new DateTime(year, month, day);20 }2122public string Name23 {24get25 {26return name;27 }2829set30 {31 name = value;32 }33 }3435public decimal Salary36 {37get38 {39return salary;4142set43 {44 salary = value;45 }46 }4748public DateTime Entryadte49 {50get51 {52return entryadte;53 }5455set56 {57 entryadte = value;58 }59 }6061public abstract string Type62 {63get;64 }6566public static double Tax(decimal earnings)67 {68decimal taxSal = earnings;69double Taxes = 0;70if (taxSal > 4000)71 {72 Taxes = Convert.ToDouble(taxSal - 4000) * 0.15;73 taxSal = 4000;74 }7576if (taxSal > 2500)77 {78 Taxes += Convert.ToDouble(taxSal - 2500) * 0.10;79 taxSal = 2500;80 }81if (taxSal > 2000)82 {83 Taxes += Convert.ToDouble(taxSal - 2000) * 0.05;84 taxSal = 2000;85 }8687return Taxes;88 }89 }下⾯就开始写各个成员类了.1//经理类2class Manager:Employee,ISalarySystem3 {4private decimal bonus;5public Manager(string name, decimal salary, int year, int month, int day, decimal bonus)6 :base(name,salary,year,month,day)7 {8this.Bonus = bonus;9 }1011public decimal Bonus12 {13get14 {15return bonus;16 }1718set19 {20 bonus = value;21 }22 }2324public override string Type25 {26get27 {28return"经理";29 }30 }31public decimal Earnings()33return Salary + bonus;34 }35public string SelfInform()36 {37return"姓名：" + Name +""+ Type + "" + "⼊职时间：" + Entryadte.ToShortDateString();38 }39 }1//销售员类2public class SalesMan:Employee,ISalarySystem3 {4private decimal commission;//提成5private float rate;6public SalesMan(string name, decimal salary, int year, int month, int day, decimal commission, float rate)7 : base(name,salary,year,month,day)8 {mission = commission;10this.Rate = rate;11 }1213public decimal Commission14 {15get16 {17return commission;18 }1920set21 {22 commission = value;23 }24 }2526public float Rate27 {28get29 {30return rate;31 }3233set34 {35 rate = value;36 }37 }3839public override string Type40 {41get42 {43return"销售员";44 }45 }46public decimal Earnings()47 {48return Salary + commission * (decimal)rate / 100;49 }5051public string SelfInform()52 {53//throw new NotImplementedException();54return"姓名：" + Name + "" + Type + "" + "⼊职时间：" + Entryadte.ToShortDateString()55 +"销售额："+commission;56 }57 }1//⼯⼈2public class Worker : Employee, ISalarySystem3 {4private decimal overtimepay;5public Worker(string name, decimal salary, int year, int month, int day,decimal overtimepay)6 :base(name,salary,year,month,day)7 {8 Name = name;9 Salary = salary;10this.Overtimepay = overtimepay;11 }1213public decimal Overtimepay14 {15get16 {17return overtimepay;1920set21 {22 overtimepay = value;23 }24 }2526public override string Type27 {28get29 {30//throw new NotImplementedException();31return"⼯⼈";32 }33 }34public decimal Earnings()35 {36//throw new NotImplementedException();37return Salary + overtimepay;38 }3940public string SelfInform()41 {42//throw new NotImplementedException();43return"姓名：" + Name + "" + Type + "" + "⼊职时间：" + Entryadte.ToShortDateString()44 +"加班⼯资："+overtimepay.ToString();45 }46 }1//HR　通过实现计算⼯资接⼝让后只要读取员⼯的的类型就可以发放⼯资2class HR3 {4private ISalarySystem member;5public HR()6 { }78internal ISalarySystem Member9 {10get11 {12return member;13 }1415set16 {17 member = value;18 }19 }2021public HR(ISalarySystem member)22 {23this.Member = member;24 }2526public decimal SetEarnings()27 {28decimal earnings = this.member.Earnings();29return earnings;30 }3132public string ReadInform()33 {34string inform = this.member.SelfInform();35return inform;36 }37 }所有的成员都实现接⼝和抽象类，每个成员⼜都有⾃⼰的属性，这样他们之间就可以实现多态了．最后我们就来测试⼀下实现的效果．static void Main(string[] args){string output=null;HR[] salType = new HR[3];Manager amanager = new Manager("李锦钧", 5000.00M, 2010, 6, 15, 800.00M);SalesMan asalesman = new SalesMan("lijinjun", 1800.00M, 2012, 4, 13, 800.00M, 20);Worker aworker = new Worker("⾦俊", 1500.00M, 2007, 5, 14, 80);HR Obj1 = new HR(amanager);HR Obj2 = new HR(asalesman);HR Obj3 = new HR(aworker);salType[1] = Obj2;salType[2] = Obj3;foreach(HR obj in salType){output += obj.ReadInform() + "⼯资:" + obj.SetEarnings().ToString() + "所得税:" + Employee.Tax(obj.SetEarnings()) + "\n"; }Console.Write(""+output);}以上就是接⼝和抽象类的使⽤案例，其中有什么不对的地⽅希望⼤家指正，不过就不要直接喷了。

一、引言Android 学习已有一年半有余，先后做过两款游戏、三款应用和搭建一台服务端，也了解过一些Android相关的源码（JDK、SDK和NDK），学习Android不仅是对前沿开发技术的了解，也是对编程知识的一次提升。

巩固和学习了更多的Android的控件、布局、Activity、Service等一系列基础知识，对整个Android的开发有了大致的了解。

android入门后，只会照着别人的葫芦来画瓢，即没有设计思想，也没有自主原创的代码，不好不好于是乎，进了公司跟着项目走，用项目来驱动自己去学习和提高公司是1+1开发模式，即1个美工 + 1个工程师，负责完成一个项目（主要是游戏开发），就完全需要自己设计游戏的布局、逻辑，以及各种动画，来增强用户体验的效果当时主要是看Android官方的SDK API文档、中文API文档、 JDK源码，对有些感念不清楚，就上论坛去找答案，如CSDN、ITEye、IBM、知乎，或者去啃google 官方的文档。

二、新掌握的Java基础学习2.1、Activity View、Surfaceview的理解掌握了常用控件、view、surfaceview使用方式，知道怎样去适配不同屏幕后，每天就是重复的工作，堆砌代码，难以进一步去提升自己于是就自己给自个找点事干，自定义控件，如对话框背景等，或去google code找些开源的代码下来研究，学习人家的设计思想、模块功能的划分、代码组织结构等知识这个过程中，涉及到的知识比较多，如版本管理工具SVN、Git、Mercurial，如设计模式的思想，如怎样构建通用的开源应用框架（考虑sdk1.5等版本），如何适用在不同屏幕分辨率的手机上等等学习中会不断遇到一个又一个新的问题，因此需要不断去查资料、再学习各种工具，逐步积累，潜移默化中自己掌握的知识和工具就多了，眼界也开阔了。

2.2、android-pulltorefresh一个强大的拉动刷新开源项目，支持各种控件下拉刷新，ListView、ViewPager、WevView、ExpandableListView、GridView、ScrollView、Horizontal ScrollView、Fragment上下左右拉动刷新，比下面johannilsson那个只支持ListView的强大的多。