抽象类的概念和讲解

原创 2018年04月15日 13:02:17
/*
	抽象类的概述:
		动物不应该定义为具体的东西,而且动物中的吃,睡等也不应该是具体的。
		我们把一个不是具体的功能称为抽象的功能,而一个类中如果有抽象的功能,该类必须是抽象类。
		
	抽象类的特点:
		A:抽象类和抽象方法必须用abstract关键字修饰
		B:抽象类中不一定有抽象方法,但是有抽象方法的类必须定义为抽象类
		C:抽象类不能实例化
			因为它不是具体的。
			抽象类有构造方法,但是不能实例化?构造方法的作用是什么呢?
			用于子类访问父类数据的初始化
		D:抽象的子类
			a:如果不想重写抽象方法,该子类是一个抽象类。
			b:重写所有的抽象方法,这个时候子类是一个具体的类。
			
		抽象类的实例化其实是靠具体的子类实现的。是多态的方式。
			Animal a = new Cat();
*/

//abstract class Animal //抽象类的声明格式
abstract class Animal {
	//抽象方法
	//public abstract void eat(){} //空方法体,这个会报错。抽象方法不能有主体
	public abstract void eat();
	
	public Animal(){}
}

//子类是抽象类
abstract class Dog extends Animal {}

//子类是具体类,重写抽象方法
class Cat extends Animal {
	public void eat() {
		System.out.println("猫吃鱼");
	}
}

class AbstractDemo {
	public static void main(String[] args) {
		//创建对象
		//Animal是抽象的; 无法实例化
		//Animal a = new Animal();
		//通过多态的方式
		Animal a = new Cat();
		a.eat();
	}
}
/*
	抽象类的成员特点:
		成员变量:既可以是变量,也可以是常量。
		构造方法:有。
					用于子类访问父类数据的初始化。
		成员方法:既可以是抽象的,也可以是非抽象的。
		
	抽象类的成员方法特性:
		A:抽象方法 强制要求子类做的事情。
		B:非抽象方法 子类继承的事情,提高代码复用性。
*/
abstract class Animal {
	public int num = 10;
	public final int num2 = 20;

	public Animal() {}
	
	public Animal(String name,int age){}
	
	public abstract void show();
	
	public void method() {
		System.out.println("method");
	}
}

class Dog extends Animal {
	public void show() {
		System.out.println("show Dog");
	}
}

class AbstractDemo2 {
	public static void main(String[] args) {
		//创建对象
		Animal a = new Dog();
		a.num = 100;
		System.out.println(a.num);
		//a.num2 = 200;
		System.out.println(a.num2);
		System.out.println("--------------");
		a.show();
		a.method();
	}
}

/*
一个类如果没有抽象方法,可不可以定义为抽象类?如果可以,有什么意义?
	A:可以。
	B:不让创建对象。

abstract不能和哪些关键字共存?
	private	冲突
	final	冲突	
	static	无意义
*/
abstract class Fu {
	//public abstract void show();
	//非法的修饰符组合: abstract和private
	//private abstract void show();
	
	//非法的修饰符组合
	//final abstract void show();	
	
	//非法的修饰符组合
	static abstract void show();
	
	public static void method() {
		System.out.println("method");
	}
}

class Zi extends Fu {
	public void show() {}
}

class AbstractDemo3 {
	public static void main(String[] args) {
		Fu.method();
	}
}
/*
	猫狗案例
		具体事物:猫,狗
		共性:姓名,年龄,吃饭

	分析:从具体到抽象
		猫:
			成员变量:姓名,年龄
			构造方法:无参,带参
			成员方法:吃饭(猫吃鱼)
			
		狗:
			成员变量:姓名,年龄
			构造方法:无参,带参
			成员方法:吃饭(狗吃肉)
			
		因为有共性的内容,所以就提取了一个父类。动物。
		但是又由于吃饭的内容不一样,所以吃饭的方法是抽象的,
		而方法是抽象的类,类就必须定义为抽象类。
		
		抽象动物类:
			成员变量:姓名,年龄
			构造方法:无参,带参
			成员方法:吃饭();
	
	实现:从抽象到具体
		动物类:
			成员变量:姓名,年龄
			构造方法:无参,带参
			成员方法:吃饭();
			
		狗类:
			继承自动物类
			重写吃饭();
			
		猫类:
			继承自动物类
			重写吃饭();
*/
//定义抽象的动物类
abstract class Animal {
	//姓名
	private String name;
	//年龄
	private int age;
	
	public Animal() {}
	
	public Animal(String name,int age) {
		this.name = name;
		this.age = age;
	}
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public int getAge() {
		return age;
	}
	
	public void setAge(int age) {
		this.age = age;
	}
	
	//定义一个抽象方法
	public abstract void eat();
}

//定义具体的狗类
class Dog extends Animal {
	public Dog() {}
	
	public Dog(String name,int age) {
		super(name,age);
	}
	
	public void eat() {
		System.out.println("狗吃肉");
	}
}

//定义具体的猫类
class Cat extends Animal {
	public Cat() {}
	
	public Cat(String name,int age) {
		super(name,age);
	}
	
	public void eat() {
		System.out.println("猫吃鱼");
	}
}

//测试类
class AbstractTest {
	public static void main(String[] args) {
		//测试狗类
		//具体类用法
		//方式1:
		Dog d = new Dog();
		d.setName("旺财");
		d.setAge(3);
		System.out.println(d.getName()+"---"+d.getAge());
		d.eat();
		//方式2:
		Dog d2 = new Dog("旺财",3);
		System.out.println(d2.getName()+"---"+d2.getAge());
		d2.eat();
		System.out.println("---------------------------");
		
		Animal a = new Dog();
		a.setName("旺财");
		a.setAge(3);
		System.out.println(a.getName()+"---"+a.getAge());
		a.eat();
		
		Animal a2 = new Dog("旺财",3);
		System.out.println(a2.getName()+"---"+a2.getAge());
		a2.eat();
		
		//练习:测试猫类
	}
}

/*
    学生案例
        具体事务:基础班学员,就业班学员
        共性:姓名,年龄,班级,学习,吃饭

    分析:
        基础班学员
            成员变量:姓名,年龄,班级
            成员方法:学习,吃饭
        就业班学员
            成员变量:姓名,年龄,班级
            成员方法:学习,吃饭
            
        得到一个学员类。
            成员变量:姓名,年龄,班级
            成员方法:学习,吃饭
            
    实现:
        学员类
        基础班学员
        就业班学员
*/
//定义抽象学员类
abstract class Student {
    //姓名
    private String name;
    //年龄
    private int age;
    //班级
    private String grand;
    
    public Student() {}
    
    public Student(String name,int age,String grand) {
        this.name = name;
        this.age = age;
        this.grand = grand;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
    
    public String getGrand() {
        return grand;
    }
    
    public void setGrand(String grand) {
        this.grand = grand;
    }
    
    //学习
    public abstract void study();
    
    //吃饭
    public void eat() {
        System.out.println("学习累了,就该吃饭");
    }
}

//具体基础班学员类
class BasicStudent extends Student {
    public BasicStudent() {}
    
    public BasicStudent(String name,int age,String grand) {
        super(name,age,grand);
    }
    
    public void study() {
        System.out.println("基础班学员学习的是JavaSE");
    }
}

//具体就业班学员类
class WorkStudent extends Student {
    public WorkStudent() {}
    
    public WorkStudent(String name,int age,String grand) {
        super(name,age,grand);
    }
    
    public void study() {
        System.out.println("就业班学员学习的是JavaEE");
    }
}

class AbstractTest3 {
    public static void main(String[] args) {
        //我仅仅测试基础班学员
        //按照多态的方式测试
        Student s = new BasicStudent();
        s.setName("林青霞");
        s.setAge(27);
        s.setGrand("1111");
        System.out.println(s.getName()+"---"+s.getAge()+"---"+s.getGrand());
        s.study();
        s.eat();
        System.out.println("--------------");
        
        s = new BasicStudent("武鑫",48,"1111");
        System.out.println(s.getName()+"---"+s.getAge()+"---"+s.getGrand());
        s.study();
        s.eat();
        
        //就业班测试留给自己玩
    }
}
/*
	假如我们在开发一个系统时需要对员工类进行设计,员工包含3个属性:姓名、工号以及工资。
	经理也是员工,除了含有员工的属性外,另为还有一个奖金属性。
	请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。
	
	分析:
		普通员工类
			成员变量:姓名、工号以及工资。
			成员方法:工作
		经理类:
			成员变量:姓名、工号以及工资,奖金属性
			成员方法:工作
			
	实现:
		员工类:
		普通员工类:
		经理类:
*/
//定义员工类
abstract class Employee {
	//姓名、工号以及工资
	private String name;
	private String id;
	private int salary;
	
	public Employee() {}
	
	public Employee(String name,String id,int salary) {
		this.name = name;
		this.id = id;
		this.salary = salary;
	}
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public String getId() {
		return id;
	}
	
	public void setId(String id) {
		this.id = id;
	}
	
	public int getSalary() {
		return salary;
	}
	
	public void setSalary(int salary) {
		this.salary = salary;
	}
	
	//工作
	public abstract void work();
}

//普通员工类
class Programmer extends Employee {
	public Programmer(){}
	
	public Programmer(String name,String id,int salary) {
		super(name,id,salary);
	}
	
	public void work() {
		System.out.println("按照需求写代码");
	}
}

//经理类
class Manager extends Employee {
	//奖金
	private int money; //bonus 奖金

	public Manager(){}
	
	public Manager(String name,String id,int salary,int money) {
		super(name,id,salary);
		this.money = money;
	}
	
	public void work() {
		System.out.println("跟客户谈需求");
	}
	
	public int getMoney() {
		return money;
	}
	
	public void setMoney(int money) {
		this.money = money;
	}
}

class AbstractTest4 {
	public static void main(String[] args) {
		//测试普通员工
		Employee emp = new Programmer();
		emp.setName("林青霞");
		emp.setId("czbk001");
		emp.setSalary(18000);
		System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary());
		emp.work();
		System.out.println("-------------");
		emp = new Programmer("林青霞","czbk001",18000);
		System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary());
		emp.work();
		System.out.println("-------------");
		
		/*
		emp = new Manager();
		emp.setName("刘意");
		emp.setId("czbk002");
		emp.setSalary(8000);
		emp.setMoney(2000);
		*/
		//由于子类有特有的内容,所以我们用子类来测试
		Manager m = new Manager();
		m.setName("刘意");
		m.setId("czbk002");
		m.setSalary(8000);
		m.setMoney(2000);
		System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney());
		m.work();
		System.out.println("-------------");
		
		//通过构造方法赋值
		m = new Manager("刘意","czbk002",8000,2000);
		System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney());
		m.work();
	}
}




c++抽象类概念

#include "Englishman.h" #include "Chinese.h" int main(int argc, char **argv) { Englishman e;...
  • joshua_love
  • joshua_love
  • 2016-10-10 15:02:09
  • 325

Java-面向对象(高级篇)--抽象类的基本概念

前面对类的继承进行了初步的讲解,通过继承可以从原来的类中派生出新的类。原有的类称为基类或父类,而新的类则称为子类或者派生类,通过继承机制,派生出的新类不仅可以保留原有类的功能,而且还可以拥有更多的功能...
  • aotumemedazhao1996
  • aotumemedazhao1996
  • 2016-10-09 21:46:44
  • 225

PHP面向对象基础概念(抽象方法和抽象类)

在OOP语言中,一个类可以有一个或多个子类,而每个类都有至少一个公有方法做为外部代码访问其的接口。而抽象方法就是为了方便继承而引入的,我们先来看一下抽象类和抽象方法的定义再说明它的用途。 什么是抽象方...
  • PHPwhite
  • PHPwhite
  • 2015-06-15 23:40:00
  • 2643

php中抽象类和接口的概念与区别

php里面的接口类,抽象类到底有什么用呢?  在我才接触php的时候,觉得这个东西没有什么用,在后来的逐渐接触大系统以后,才发现其实这些东西还是有一定的作用的,下面我就简单的说说。   1.php...
  • u011829023
  • u011829023
  • 2016-02-19 11:56:05
  • 589

接口和抽象类定义规则

接口interface关键字用来声明一个接口,它可以产生一个完全抽象的类,并且不提供任何具体实现。一旦定义完,任何类都可以实现接口,另外,类可以实现任意数目的接口。一个类要实现一个接口,必须创建由接口...
  • sunzuqiang
  • sunzuqiang
  • 2010-05-24 23:24:00
  • 3206

接口 抽象类 实体类

接口可以继承(多)接口, 接口不可以继承抽象类:接口里的方法是不能有方法体的,但抽象类的方法是可以有方法体的,继承后,在这一点上就会产生矛盾。 抽象类可以实现(多)接口,但不能继承接口。 抽象类可...
  • jxq0816
  • jxq0816
  • 2015-01-21 16:25:17
  • 1024

C#中的虚方法、抽象方法、抽象类以及接口

众所周知,C#作为一门OOP(面向对象程序设计)语言,在许多地方都有与C++相似的地方,然而也有很多不同的地方。 说到面向对象,脑袋里第一反应当然就是面向对象的三大原则(java中是四大原则):...
  • czc1997
  • czc1997
  • 2017-12-12 19:57:52
  • 127

抽象类与一般类的区别

抽象类与一般类的区别适合初学者 首先了解一下百度百科对抽象类的定义:抽象类往往用来表征对问题领域进行分析、设计中得出的抽象概念,是对一系列看上去不同,但是本质上相同的具体概念的抽象。 用通俗的语言来说...
  • Just_do_it_HZF
  • Just_do_it_HZF
  • 2017-07-25 16:12:48
  • 269

Java中抽象类和接口定义

/** * * @author zhaocx1 * */ /* * 当多个类中出现相同功能,但是功能主提体不同。 这时可以进行向上抽取。这时,只抽取功能定义,而不抽取功能主体。 * ...
  • nancy199006
  • nancy199006
  • 2015-02-05 12:48:13
  • 721

php中抽象类和接口的概念和区别

1. 一个子类implements一个接口,如果该子类是非abstract类,就必须实现接口中的所有方法(不管是否需要);而如果该子类是abstract类 ,则可以实现接口的中方法也可以不实现...
  • candy19890214
  • candy19890214
  • 2013-10-10 17:07:53
  • 653
收藏助手
不良信息举报
您举报文章:抽象类的概念和讲解
举报原因:
原因补充:

(最多只允许输入30个字)