Java篇--抽象类和接口

抽象类与接口


 抽象类


  抽象类特点


抽象类的概述：


动物不应该定义为具体的东西，而且动物中的吃，睡等也不应该是具体的。


我们把一个不是具体的功能称为抽象的功能，而一个类中如果有抽象的功能，该类必须是抽象类。


抽象类的特点：


A:抽象类和抽象方法必须用abstract关键字修饰


B:抽象类中不一定有抽象方法,但是有抽象方法的类必须定义为抽象类


C:抽象类不能实例化


因为它不是具体的。


抽象类有构造方法，但是不能实例化?构造方法的作用是什么呢?


用于子类访问父类数据的初始化


D:抽象的子类


a:如果不想重写抽象方法，该子类是一个抽象类。


b:重写所有的抽象方法，这个时候子类是一个具体的类。


抽象类的实例化其实是靠具体的子类实现的。是多态的方式。


  抽象类成员的特点


抽象类的成员特点：


成员变量：既可以是变量，也可以是常量。


构造方法：有。


用于子类访问父类数据的初始化。


成员方法：既可以是抽象的，也可以是非抽象的。


抽象类的成员方法特性：


A:抽象方法 强制要求子类做的事情。


B:非抽象方法 子类继承的事情，提高代码复用性。


 接口


  接口特点


接口的特点：


A:接口用关键字interface表示


interface 接口名 {}


B:类实现接口用implements表示


class 类名 implements 接口名 {}


C:接口不能实例化


那么，接口如何实例化呢?


按照多态的方式来实例化。


D:接口的子类


a:可以是抽象类。但是意义不大。


b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)


由此可见：


A:具体类多态(几乎没有)


B:抽象类多态(常用)


C:接口多态(最常用)


  接口成员特点


接口成员特点


成员变量；只能是常量，并且是静态的。


默认修饰符：public static final


建议：自己手动给出。


构造方法：接口没有构造方法。


成员方法：只能是抽象方法。


默认修饰符：public abstract


建议：自己手动给出。


所有的类都默认继承自一个类：Object。


类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。


  类与类,类与接口以及接口与接口的关系


类与类：


继承关系,只能单继承,可以多层继承。


类与接口：


实现关系,可以单实现,也可以多实现。


并且还可以在继承一个类的同时实现多个接口。


接口与接口：


继承关系,可以单继承,也可以多继承。


  抽象类和接口的区别


成员区别


抽象类 变量,常量;有抽象方法;抽象方法,非抽象方法


接口 常量;抽象方法


关系区别


类与类 继承，单继承


类与接口 实现，单实现，多实现


接口与接口 继承，单继承，多继承


设计理念区别


抽象类 被继承体现的是：”is a”的关系。共性功能


接口 被实现体现的是：”like a”的关系。扩展功能


  形式参数和返回值问题


形式参数


 基本类型


 引用类型


返回值类型


 基本类型


 引用类型


链式编程

类名

/*
	形式参数：
		基本类型
		引用类型
			类名:(匿名对象的时候其实我们已经讲过了) 需要的是该类的对象
			抽象类:
			接口
*/
class Student {
	public void study() {
		System.out.println("Good Good Study,Day Day Up");
	}
}

class StudentDemo {
	public void method(Student s) { //ss; ss = new Student();  Student s = new Student();
		s.study();
	}
}

class StudentTest {
	public static void main(String[] args) {
		//需求：我要测试Student类的study()方法
		Student s = new Student();
		s.study();
		System.out.println("----------------");
		
		//需求2：我要测试StudentDemo类中的method()方法
		StudentDemo sd = new StudentDemo();
		Student ss = new Student();
		sd.method(ss);
		System.out.println("----------------");
		
		//匿名对象用法
		new StudentDemo().method(new Student());
	}
}

抽象类

/*
	形式参数：
		基本类型
		引用类型
			类名:(匿名对象的时候其实我们已经讲过了)需要的是该类的对象
			抽象类:需要的是该抽象的类子类对象
			接口
*/
abstract class Person {
	public abstract void study();
}

class PersonDemo {
	public void method(Person p) {//p; p = new Student();  Person p = new Student(); //多态
		p.study();
	}
}

//定义一个具体的学生类
class Student extends Person {
	public void study() {
		System.out.println("Good Good Study,Day Day Up");
	}
}

class PersonTest {
	public static void main(String[] args) {
		//目前是没有办法的使用的
		//因为抽象类没有对应的具体类
		//那么，我们就应该先定义一个具体类
		//需求：我要使用PersonDemo类中的method()方法
		PersonDemo pd = new PersonDemo();
		Person p = new Student();
		pd.method(p);
	}
}

接口:需要的是该接口的实现类对象

/*
	形式参数：
		基本类型
		引用类型
			类名:(匿名对象的时候其实我们已经讲过了)需要的是该类的对象
			抽象类:需要的是该抽象的类子类对象
			接口:需要的是该接口的实现类对象
*/
//定义一个爱好的接口
interface Love {
	public abstract void love();
}

class LoveDemo {
	public void method(Love l) { //l; l = new Teacher();  Love l = new Teacher(); 多态
		l.love();
	}
}

//定义具体类实现接口
class Teacher implements Love {
	public void love() {
		System.out.println("老师爱学生,爱Java,爱林青霞");
	}
}

class TeacherTest {
	public static void main(String[] args) {
		//需求：我要测试LoveDemo类中的love()方法
		LoveDemo ld = new LoveDemo();
		Love l = new Teacher();
		ld.method(l);
	}
}

类名作为返回值

/*
	返回值类型
		基本类型:
		引用类型：
			类:返回的是该类的对象
			抽象类:
			接口:
*/
class Student {
	public void study() {
		System.out.println("Good Good Study,Day Day Up");
	}
}

class StudentDemo {
	public Student getStudent() {
		//Student s = new Student();
		//Student ss = s;
		
		//Student s = new Student();
		//return s;
		return new Student();
	}
}

class StudentTest2 {
	public static void main(String[] args) {
		//需求：我要使用Student类中的study()方法
		//但是，这一次我的要求是，不要直接创建Student的对象
		//让你使用StudentDemo帮你创建对象
		StudentDemo sd = new StudentDemo();
		Student s = sd.getStudent(); //new Student(); Student s = new Student();
		s.study();
	}
}

抽象类作为返回值

/*
	返回值类型
		基本类型:(基本类型太简单，我不准备讲解)
		引用类型：
			类:返回的是该类的对象
			抽象类:返回的是该抽象类的子类对象
			接口:
*/
abstract class Person {
	public abstract void study();
}

class PersonDemo {
	public Person getPerson() {
		//Person p = new Student();
		//return p;
		
		return new Student();
	}
}

class Student extends Person {
	public void study() {
		System.out.println("Good Good Study,Day Day Up");
	}
}

class PersonTest2 {
	public static void main(String[] args) {
		//需求：我要测试Person类中的study()方法
		PersonDemo pd = new PersonDemo();
		Person p = pd.getPerson(); //new Student();  Person p = new Student(); 多态
		p.study();
	}
}

接口作为返回值

/*
	返回值类型
		基本类型:(基本类型太简单，我不准备讲解)
		引用类型：
			类:返回的是该类的对象
			抽象类:返回的是该抽象类的子类对象
			接口:返回的是该接口的实现类的对象
*/
//定义一个爱好的接口
interface Love {
	public abstract void love();
}

class LoveDemo {
	public Love getLove() {
		//Love l = new Teacher();
		//return l;
		
		return new Teacher();
	}
}

//定义具体类实现接口
class Teacher implements Love {
	public void love() {
		System.out.println("老师爱学生,爱Java,爱林青霞");
	}
}

class TeacherTest2 {
	public static void main(String[] args) {
		//如何测试呢?
		LoveDemo ld = new LoveDemo();
		Love l = ld.getLove(); //new Teacher(); Love l = new Teacher(); 多态
		l.love();
	}
}

链式编程

/*
	链式编程。
		每次调用完毕方法后，返回的是一个对象。
*/
class Student {
	public void study() {
		System.out.println("Good Good Study,Day Day Up");
	}
}

class StudentDemo {
	public Student getStudent() {
		return new Student();
	}
}

class StudentTest3 {
	public static void main(String[] args) {
		//如何调用的呢?
		StudentDemo sd = new StudentDemo();
		//Student s = sd.getStudent();
		//s.study();
		
		//大家注意了
		sd.getStudent().study();
	}
}