从抽象类到接口—手把手教你写抽象类（一）—还在Ctrl C的伙伴们看过来了

package com.demo01;
/*
 * abstract:关键字，用于修饰方法和类
 * 抽象方法：不同类的方法是相似，但是具体内容又不太一样，所以我们只能抽取他的声明，没有具体的方法体，没有具体方法体的方法就是抽象方法
 * 抽象类：有抽象方法的类必须是抽象类
 * 
 * 注意：一个类继承了抽象类需要重写他所有的抽象方法,否则这个类就得是抽象类
 */
public class ExtendsDemo {

}
abstract class Animal {
	// 抽像方法
	public abstract void eat();  // 没有方法体的方法
	
	//非抽象方法子类可以不重写
	public void run() {
		
	}
}

// 猫的子类 必须要实现eat方法
class Cat extends Animal {
	// 证明实现的是父类里边的方法，或者是继承的父类里边的方法
	@Override
	// 这个必须要实现父类里边的抽象方法，否则会报错
	public void eat() {
		System.out.println("猫吃鱼");
	}
}

//狗的抽象子类
abstract class Dog extends Animal {
	// 这个方法可以不是现父类里边的方法，因为它也是一个抽象类
	public void eat() {
		System.out.println("狗吃屎");
	}
}

抽象类的特点

抽象方法一定在抽象类中，不可能在一个普通类中定义抽象类
抽象方法和抽象类都必须被abstract关键字修饰
抽象类不可以用new创建对象，因为调用抽象方法没意义
抽象类中的抽象方法要被使用，必须由子类覆写其所有的抽象方法后，建立子类对象调用；如果子类只覆盖了部分的抽象方法，那么该子类还是一个抽象类。
抽象类中可以有抽象方法也可以有非抽象方法
抽象类和一般类没有太大的不同：该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂得东西。这些不确定的部分，也是该事物的功能，需要明确出现。但是无法定义主体,也就是比一般类多了抽象方法而已.
特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象

我们用代码对上诉理解进行解释，代码如下：

package com.demo01;

/*
 * 抽象类的特点：
 * 		抽象方法只能在抽象类里面
 * 		抽象类和抽象方法必须被abstract修饰
 * 		抽象类不能创建对象（不能实例化）
 * 		抽象类中可以有非抽象的方法
 * 		抽象类和类的关系也是继承
 * 		一个类继承了抽象类要么重写所有的抽象方法，要么他自己是抽象类
 */
public class ExtendsDemo {
	public static void main(String[] args) {
		//Animal a = new Animal();
		Cat cat = new Cat();
		cat.eat();
		cat.sleep();
		cat.run();
	}
}

// 抽象类
abstract class Animal {
	// 非抽象方法
	public void eat() {
		
	}
	// 非抽象方法
	public void sleep() {
		
	}
	
	// 抽象方法
	public abstract void run() ;
}

// 非抽象类
class Cat extends Animal {


	@Override
	public void sleep() {
		// TODO Auto-generated method stub
		
	}
	
	public void run(){
	}

}

抽象类成员特点

成员变量

–可以有变量

–可以有常量

构造方法

–可以有构造方法

成员方法

–可以有抽象方法

–可以有非抽象方法

注：既然你是一个构造方法，我们在调用类的时候，首先调用的是一个构造方法，普通的构造方法是和对象一起存在的，如果你是一个抽象的构造方法，根本就么有意义，构造方法不可以是一个抽象的方法的。

代码理解如下：

package com.demo01;

import com.demo01.Animal;
import com.demo01.Dog;

/*
 * 抽象类的成员特点：
 * 		成员变量
 * 			可以有成员变量
 * 			可以有常量
 * 		成员方法
 * 			可以有抽象方法
 * 			可以有非抽象方法
 * 		构造方法
 * 			可以有构造方法的，需要对抽象类的成员变量进行初始化
 * 
 * final:修饰类、成员变量、成员方法
 */
public class ExtendsDemo {
	public static void main(String[] args) {
		Dog d = new Dog();
		d.barking();
		d.eat();
	}
}

// 抽象类
abstract class Animal {
	String name = "哮天犬";
	// 常量修饰符，不可以被修改，不可以赋新的值
	final int NUM = 10;
	
	public Animal() {
		System.out.println("我是抽象类的构造方法");
	}
	
	public Animal(int n) {
		System.out.println("我是抽象类的构造方法");
	}
	
	public abstract void eat();
	
	public void run() {
		
	}
}

// 子类继承父类
class Dog extends Animal {

	public void barking() {
		
		System.out.println(name);
		System.out.println(NUM);
	}

	
	public void eat() {
		System.out.println("吃");
		
	}
}

抽象类的案例

老师示例，根据给出内容设计继承体系

–具体事物：基础班老师，就业班老师

–共性：姓名，所属教室，讲课。

学员示例(练习)——类似，自己练习哈

–具体事物：基础班学员，就业班学员

–共性：姓名，学习

代码如下：

package com.demo01;

import com.demo01.BasicTeacher;
import com.demo01.JobTeacher;
import com.demo01.Teacher;

/*
 *	基础班老师，就业班老师
 *
 *	共性：
 *		属性	姓名，年龄，性别
 *		行为	讲课，唱歌
 */
public class ExtendsDemo {
	public static void main(String[] args) {
		BasicTeacher bt = new BasicTeacher();
		bt.name = "张老师";
		bt.teach();
		
		JobTeacher jt = new JobTeacher();
		jt.name = "王老师";
		jt.teach();
	}
}

//定义一个抽象类（父类）
abstract class Teacher {
	
	String name;//姓名
	int age;//年龄
	String gender;//性别
	
	//讲课
	public abstract void teach();
}

// 定义一个子类
class BasicTeacher extends Teacher {

	@Override
	public void teach() {
		System.out.println(name + "讲基础班课程");
		
	}
	
}

class JobTeacher extends Teacher {

	@Override
	public void teach() {
		System.out.println(name + "讲就业班课程");
	}
	
}

抽象类的细节

抽象关键字abstract不可以和哪些关键字共存？

答：不可以和final、paivate共用，(1)加上final关键字意思是不能被继承，而abstract不能创建对象，只能被继承，然后创建对象来访问抽象类中的成员变量和成员方法，所以abstract不能和final共用。(2)abstract必须要被别人继承使用，pravite是私有的，其他得类，谁都看不到。