javaSE学习的week06

1. 抽象类

package cn.hncu_01;
/*
 * 抽象类
 * 	动物不应该定义成具体的东西,而且动物中的吃饭,睡觉也不应该是具体的.
 * 	我们把一个不是具体的方法称为抽象方法,如果一个类中存在抽象方法,则这个类是抽象类.
 * 
 * 抽象类的特点
 * 	(1) 抽象类和抽象方法用abstract修饰.
 * 	(2)	抽象类不一定有抽象方法,但是有抽象方法的类一定是抽象类
 * 	(3) 抽象类不能直接实例化.可以通过多态的方式实例化.
 * 			因为抽象类不是具体的.
 * 			抽象类有没有构造方法?
 * 				有.用于子类访问父类数据的初始化.
 * 	(4)	抽象类的子类
 * 			抽象类:可以不重写父类的抽象方法
 * 			具体类:重写所有的抽象方法.
 * 
 * 抽象类成员的特点:
 * 	(1)	成员变量
 * 			可以是变量也可以是常量
 * 			
 * 	(2) 构造方法
 * 			有构造方法.用于子类访问父类数据的初始化
 * 	(3) 成员方法
 * 			既可以是抽象方法,也可以是具体方法.
 * 
 * 思考:
 * 	一个类如果没有抽象方法,可以定义为抽象类吗?如果可以,有什么意义?
 * 		可以.不让创建对象.
 */
//定义一个抽象的动物类
abstract class  Animal {
	int a=10;
	final int b=20;
	public Animal(){
		
	}
	abstract void eat();
	void sleep(){
		
	}
}

class Dog extends Animal{
	@Override
	void eat() {
		// TODO Auto-generated method stub
	}
	
}
abstract class Cat extends Animal{
	
}
public class Demo {
	public static void main(String[] args) {
		//Animal a = new Animal();
	}
}

2. 抽象类的应用

package cn.hncu_02;
/*
 * 猫狗案例(抽象类版本)
 */
abstract class Animal{
	private String name;
	private int age;
	//注意:抽象方法没有方法体,连大括号也没有
	public abstract void eat();	
	public abstract void sleep();
}

class Dog extends Animal{
	public void eat() {
		System.out.println("狗吃肉");
	}
	public void sleep() {
		System.out.println("狗趴着睡觉");
	}
	public void lookDoor() {
		System.out.println("狗看门");
	}
}
class Cat extends Animal {

	public void eat() {
		System.out.println("猫吃鱼");
	}
	public void sleep() {
		System.out.println("猫躺着睡");
	}	
	public void catchMouse(){
		System.out.println("猫捉老鼠");
	}
}

public class Demo {
	private void main() {
		//用多态的方式实例化一个抽象类
		Animal a = new Dog();
		a.eat();
		a.sleep();
		Dog dog = (Dog) a;
		dog.lookDoor();
		//猫类自己测试
		
	}
}

3. 接口的特点

package cn.hncu_03;
/*
 * 接口的特点:
 * 	(1) 定义接口用关键字:inteface,格式
 * 		interface 接口名 {}
 * 	(2) 实现一个接口用关键字(这个类我们一般称为实现类,实现类一般认为接口的子类):implement,格式
 * 		class 类名 implement 接口名{}
 * 	(3) 接口的子类(接口实现类)
 * 			可以是抽象类:可以不实现接口中的抽象方法.但是这个一般没有意义.
 * 			可以是具体类:必须重写接口中的所有抽象方法. 推荐使用.
 * 
 * 接口成员的特点:
 * 	(1)成员变量
 * 		只能是常量,默认修饰符是 public static final
 * 		建议初学者手动给出.
 * 	(2)构造方法
 * 		没有构造方法
 * 	(3)成员方法
 * 		只能是抽象方法,默认修饰符是public abstract
 * 		建议初学者手动给出.
 * 	
 * 
 * 
 */
interface Computing {
	int a=10;//public static final int a=10
	
	/*public Computing(){
		
	}*/
	
	public void computing();//public abstract void computing();
}

class Dog implements Computing{

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

abstract class Cat implements Computing{
	
}

public class Demo {

}

package cn.hncu_04;
/*
 * 类与类,类与接口,接口与接口的关系
 * 
 * 类与类:
 * 		继承关系,只能单继承,不能多继承,可以多层继承
 * 
 * 类与接口:
 * 		实现关系,可以单实现,也可以多实现
 * 
 * 接口与接口:
 * 		继承关系,可以单继承,也可以多继承
 * 
 * 抽象类与接口的区别:
 * 	A 成员区别
 * 		抽象类
 * 			成员变量:可以是变量,也可以是常量
 * 			构造方法:有构造方法,不能直接实例化
 * 			成员方法:可以是抽象的,也可以是具体的
 * 
 * 		接口
 * 			成员变量:只能是变量,默认修饰符:public static final
 * 			构造方法:没有构造方法
 * 			成员方法: 只能是抽象的,默认修饰符: public abstract
 * B 关系的区别
 * 		类与类:继承,单继承
 * 		类与接口:实现,可以多实现
 * 		接口与接口:继承关系,可以多继承
 * C 设计理念的区别
 * 		抽象类定义的是该继承体系中的共性功能.
 * 		抽象类定义的是该继承体系中的扩展功能
 */

interface Father {
	
}
interface Mother{
	
}
interface Son extends Father,Mother{
	
}
interface Interface1 {
	
}
interface Interface2 {
	
}
class Test implements Interface1,Interface2{
	
}

public class Demo {

}

4. 接口的练习

package cn.hncu_05;

/*
 * 猫狗案例最终版,加入跳高的额外功能
 * 
 * 分析:
 * 	interface Jumping{void jumping();}
 * 	动物类(抽象类)
 * 	猫类 	继承	动物类	具体类
 * 	狗类	继承	动物类	具体类
 * 	跳高的狗类	继承	狗类	实现跳高
 * 
 * 	测试类
 * 		
 */
interface Jumping {
	void jumping();
}

abstract class Animal {
	private String name;
	private int age;

	public Animal() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Animal(String name, int age) {
		super();
		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 {

	@Override
	public void eat() {
		System.out.println("狗吃肉");
	}
	
	public void lookDoor(){
		System.out.println("狗看门");
	}
}

class Cat extends Animal {

	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}
	
	public void catchMouse(){
		System.out.println("猫捉老鼠");
	}
}

class JumpingDog extends Dog implements Jumping{

	@Override
	public void jumping() {
		System.out.println("这是一条会跳高的狗");
	}
	
}

public class Demo {
	public static void main(String[] args) {
		JumpingDog jd = new JumpingDog();
		jd.eat();
		jd.jumping();
		jd.lookDoor();
	}
}

package cn.hncu_05;

/*
 * 老师和学生案例,加入抽烟的额外功能
 * 
 * 抽烟接口
 * 人类	抽象类	
 * 老师类	继承自人类	具体类
 * 学生类	继承自人类	具体类
 * 抽烟的老师	继承自老师类	具体类
 * 抽烟的学生	继承自学生		具体类 
 */
interface Smoking {
	public abstract void smoking();
}

abstract class Person {
	private String name;
	private int age;

	public Person() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Person(String name, int age) {
		super();
		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 Student extends Person {

	@Override
	public void eat() {
		System.out.println("学生都吃香的,喝辣的");
	}
	
	public void study(){
		System.out.println("学生都要好好学习");
	}
	
}

class Teacher extends Person {

	@Override
	public void eat() {
		System.out.println("老师吃幸福午餐");
	}
	
	public void teach(){
		System.out.println("没有听不懂的学生,只有不会教的老师");
	}
}

class SmokingStudent extends Student implements Smoking{

	@Override
	public void smoking() {
		System.out.println("学生不能抽烟");
	}
	
}

class SmokingTeacher extends Teacher implements Smoking {

	@Override
	public void smoking() {
		System.out.println("老师上课太累了,下课后要抽烟");
	}
	
}

public class Demo2 {
	public static void main(String[] args) {
		SmokingStudent ss = new SmokingStudent();
		ss.eat();
		ss.study();
		ss.smoking();
	}
}