Java-面向对象基础-6一、抽象类的用法 二、接口 三、接口的用法 四、程序设计 六、接口的多继承多实现 七、总结 八、访问控制符 九、拓展

知识点：

        抽象类 接口 面向接口开发

一、抽象类的用法

1.1 复习:抽象类构造函数测试

package cn.mbh.oop;
/**
*@author MBH:
*@version 创建时间：2022年7月10日 下午6:50:02
*/
/**本类用于测试抽象类的构造函数的用法*/
/**总结:
* 1.抽象类中可以有构造方法
* 2.父类的构造方法要优先于子类的执行
* 2.抽象类中的构造方法存在的目的,不是为了创建抽象类本身的对象,而是为了创建子类对象时使用的
*/
public class Test4_Abstract2 {

	public static void main(String[] args) {
		//4.创建多态对象进行测试
		Animal3 a = new Dog3();
		//5.测试抽象类是否可以创建对象?---不能!
		//Animal3 a3 = new Animal3();

	}

}
//1.创建抽象父类
abstract class Animal3{
	//3.创建抽象类的构造函数
	public Animal3() {
		//如果此处传参,会覆盖无参构造,子类super就报错了
		System.out.println("Animal3....构造方法");
	}
}
//2.创建子类
class Dog3 extends Animal3{
	//5.创建子类无参构造,无参构造默认存在
	public Dog3() {
		super();//隐藏着super();//先访问父类的构造方法,再执行自己的功能
		System.out.println("Dog3...构造方法");
	}
}

1.2 练习 1:抽象类成员测试

package cn.mbh.oop;
/**
*@author MBH:
*@version 创建时间：2022年7月10日 下午7:19:10
*/
/**本类用于测试抽象类中的成员*/
public class Test1_Abstract {

	public static void main(String[] args) {
		//4.创建多态对象进行测试
		Fruit f = new Apple();
		System.out.println(f.sum);//10
		//name = "lemon";//常量值补课修改
		System.out.println(f.name);//banana

	}

}
//1.创建抽象父类--水果类
abstract class Fruit{
	/**1.抽象类中可以有成员变量吗?--可以!!!*/
	//3.1创建抽象父类成员变量
	int sum = 10;
	/**2.抽象类中可以有成员常量,但是值无法修改*/
	//3.2创建抽象父类成员常量
	final String name = "banana";
	/**3.抽象类中可以有普通成员方法,也可以都是普通方法*/
	/**4.如果一个类中都是普通方法,这个类为什么还要被声明成抽象类呢?
	* 原因:抽象类不可以创建对象,如果不想让外界创建本类的对象,可以把普通类声明成一个抽象类
	* */
	//5.创建普通成员方法*2
	public void eat(){
		System.out.println("吃啥水果都行");
	}
	public void eat2(){
		System.out.println("吃啥水果都行");
	}
	/**5.抽象类中可以有抽象方法,一旦类中有抽象方法,这个类必须被声明成抽象类*/
	abstract public void clean();
}
/**6.当一个类继承了父类,父类是一个抽象类时
* 子类需要重写抽象父类的所有抽象方法,或者把自己变成一个抽象子类
* */
//解决方案一:抽象子类
//abstract class Apple extends Fruit{ }
//解决方案二:
//2.创建子类 -- 苹果类 :普通子类+重写父类的抽象方法
class Apple extends Fruit{
	//子类重写父类的抽象方法clean()
	@Override //表示这个方法是一个重写的方法
	public void clean() {
		System.out.println("苹果还是需要好好洗洗再吃的");
	}
}

abstract class Animal{

        abstract public void eat();

        abstract public void sleep();

}

class Dog extends Animal{

        eat(){......}

}

class Cat extends Animal{

        eat(){......}

}

class Pig extends Animal{

        eat(){......}

}

二、接口

2.1 概念

2.3 特点

2.4 练习 2-1:创建接口

package cn.mbh.inter;
/**
*@author MBH:
*@version 创建时间：2022年7月10日 下午7:32:42
*/
/**本接口是创建接口测试*/
/**1.通过interface关键字来定义接口*/
public interface Inter {
	/**2.接口中可以有普通方法吗?--不可以!!!*/
	//public void eat() {}
	/**3.接口中可以有抽象方法吗?--可以,接口中的方法都是抽象方法!!!*/
	public void eat();
	public void play();

}

2.5 练习 2-2:创建接口实现类

package cn.mbh.inter;
/**
*@author MBH:
*@version 创建时间：2022年7月10日 下午7:35:42
*/
/**本类作为Inter接口的实现类*/
/**1.实现类如果想用接口的功能,要和接口发生实现关系,通过关键字implements*/
/**2.1方案一:实现类实现了接口以后,可以把自己变成一个抽象子类*/
//abstract public class InterImpl implements Inter{ }
/**2.2方案二:实现类实现了接口后,还可以重写接口中所有抽象方法*/
public class InterImpl implements Inter{

	@Override//标记重写了父接口的方法
	public void eat() {
		System.out.println("吃火锅");
		
	}

	@Override//标记重写了父接口的方法
	public void play() {
		System.out.println("玩代码");
		
	}

}

2.6 练习 2-3:创建接口测试类

package cn.mbh.inter;
/**
*@author MBH:
*@version 创建时间：2022年7月10日 下午7:39:34
*/
/**本类用于测试接口实现类*/
public class InterTests {
	//1.创建入口main()
	public static void main(String[] args) {
		//2.创建多态对象进行测试
		Inter inter = new InterImpl();
		inter.eat();
		inter.play();
		//3.接口可以创建对象吗?--不行!!!
		//Inter inter = new Inter();

	}

}

三、接口的用法

3.1 练习 3-1:接口之构造方法

package cn.mbh.inter;
/**
*@author MBH:
*@version 创建时间：2022年7月10日 下午7:42:57
*/
/**本类用于测试接口的使用*/
public class Test5_UseInter {

	public static void main(String[] args) {
		//3.在main()创建多态对象进行测试
		/**问题:子类创建对象时,会自动调用父类的构造方法,但现在的父级是个接口
		* 接口没有构造方法,那子类中super()调用的是什么呢?
		* 结论1:子类默认继承了顶级父类Object,super()会自动调用Object的无参构造
		* */
		Inter2 in = new Inter2Impl();

	}

}

//1.创建接口
interface Inter2{
	/**1.接口里有构造方法吗?--没有!!!*/
	//public Inter2() {}
}
//2.创建接口的实现类
class Inter2Impl implements Inter2{
	public Inter2Impl() {
		super();//默认先调用顶级父类Object的无参构造方法
		System.out.println("Inter2Impl的无参构造");
	}
}

3.2 练习 3-2:接口之成员变量

package cn.mbh.inter;
/**
*@author MBH:
*@version 创建时间：2022年7月10日 下午7:42:57
*/
/**本类用于测试接口的使用*/
public class Test5_UseInter {

	public static void main(String[] args) {
		//3.在main()创建多态对象进行测试
		/**问题:子类创建对象时,会自动调用父类的构造方法,但现在的父级是个接口
		* 接口没有构造方法,那子类中super()调用的是什么呢?
		* 结论1:子类默认继承了顶级父类Object,super()会自动调用Object的无参构造
		* */
		Inter2 in = new Inter2Impl();
		System.out.println(in.age);
		/**结论2.1接口中的变量都是静态变量,可以通过接口名直接调用*/
		System.out.println(Inter2.age);
		/**结论2.2接口中的变量都是常量,不能被重新赋值*/
		//Inter2.age = 20;
	}

}

//1.创建接口
interface Inter2{
	/**1.接口里有构造方法吗?--没有!!!*/
	//public Inter2() {}
	/**2.接口里可以有成员变量吗?--没有!!!*/
	int age = 10;//静态常量,实际上:final static int age =10;
}
//2.创建接口的实现类
class Inter2Impl implements Inter2{
	public Inter2Impl() {
		super();//默认先调用顶级父类Object的无参构造方法
		System.out.println("Inter2Impl的无参构造");
	}
}

3.3 练习 3-3:接口之成员方法

package cn.mbh.inter;
/**
*@author MBH:
*@version 创建时间：2022年7月10日 下午7:42:57
*/
/**本类用于测试接口的使用*/
public class Test5_UseInter {

	public static void main(String[] args) {
		//3.在main()创建多态对象进行测试
		/**问题:子类创建对象时,会自动调用父类的构造方法,但现在的父级是个接口
		* 接口没有构造方法,那子类中super()调用的是什么呢?
		* 结论1:子类默认继承了顶级父类Object,super()会自动调用Object的无参构造
		* */
		Inter2 in = new Inter2Impl();
		System.out.println(in.age);
		/**结论2.1接口中的变量都是静态变量,可以通过接口名直接调用*/
		System.out.println(Inter2.age);
		/**结论2.2接口中的变量都是常量,不能被重新赋值*/
		//Inter2.age = 20;
	}

}

//1.创建接口
interface Inter2{
	/**1.接口里有构造方法吗?--没有!!!*/
	//public Inter2() {}
	/**2.接口里可以有成员变量吗?--没有!!!*/
	int age = 10;//静态常量,实际上:final static int age =10;
	/**3.接口里可以有抽象方法*/
	abstract public void eat2();
	void eat();//可以简写--会自动拼接public abstract
}
//2.创建接口的实现类
class Inter2Impl implements Inter2{
	public Inter2Impl() {
		super();//默认先调用顶级父类Object的无参构造方法
		System.out.println("Inter2Impl的无参构造");
	}
	/**4.如果接口中添加了抽象方法,实现类中需要添加所有未实现的抽象方法*/
	@Override
	public void eat2() {
	}
	@Override
	public void eat() {
	}
}

四、程序设计

4.1 分析老师示例-面向抽象编程

具体事物：实习老师 正式老师

共性：讲课，备课

/**
*@author MBH:
*@version 创建时间：2022年7月10日 下午7:51:40
*/

public class Test6_design {

}
//生活中的事物--java类
//特征--属性 行为--方法
//把所有的共性内容向上抽取形成父类
/**2.类中含有抽象方法,这个类必须变成抽象类*/
abstract class Teacher{
	//讲课
	/**1.没有方法体的方法叫做抽象方法*/
	abstract public void teach();
	//备课
	public void ready() {
		System.out.println("正在备课");
	}
}
//实习老师
class SXTeacher extends Teacher{
	//讲课
	@Override
	public void teach() {
		System.out.println("讲课");
	}
	//备课
	@Override
	public void ready() {
		System.out.println("正在备课");
	}
	
}
//正式老师--基础加强+框架加强+高新技术
class ZSTeacher extends Teacher{
	//讲课
	@Override
	public void teach() {
		System.out.println("正在讲课...基础加强+框架加强+高新技术");
	} 
}
//Scala大数据老师--Scala+Spark
abstract class ScalaTeacher extends Teacher{
}

4.2 分析老师示例-面向接口编程

具体事物：培优班老师， 高手班老师

共性：讲课，备课

package cn.mbh.design;
/**
*@author MBH:
*@version 创建时间：2022年7月10日 下午8:04:20
*/
/**本类用于设计老师类,面向接口编程*/
public class Test7_DesignInter {

}
//抽取共性,形成抽象层--体现接口--定义规则
/**1.通过interface关键字定义接口*/
interface Teacher2{
	/**2.接口中的方法都是抽象方法*/
	/**3.接口中的方法可以简写--自动拼接public abstract*/
	//讲课方法
	void teach();
	//备课方法
	void ready();
}
/**4.实现类要使用接口的功能,需要发生实现关系*/
//实习老师
class SXTeacher2 implements Teacher2{
	@Override
	public void teach() {
	}
	@Override
	public void ready() {
		System.out.println("备课电商项目");
	}
}
//正式老师
abstract class ZSTeacher2 implements Teacher2{ }

六、接口的多继承多实现

6.1 代码示例

package cn.mbh.design;
/**
*@author MBH:
*@version 创建时间：2022年7月10日 下午8:07:43
*/
public class Test8 {

	public static void main(String[] args) {
		//创建多态对象进行测试
		Inter1 in = new InterImpl();
		in.delete();
		in.save();
		//in.update();//运行看右边(子类),不能调用子类特有的方法

	}

}
//1.创建接口1
interface Inter1{
	void save();
	void delete();
}
//2.创建接口2
interface Inter2{
	void update();
	void find();
}
//4.创建接口3测试接口间的继承关系
/**2.接口之间可以发生继承关系,而且可以多继承,用逗号隔开*/
interface Inter3 extends Inter1,Inter2{}
/**3.实现类,可以继承的时候同时多实现
* 注意:由于java是单继承 多实现,所以先写继承,再写实现
* * */
//class InterImpl extends Object implements inter1,inter2{}
/**1.接口和实现类之间可以发生实现关系,通过implements关键字来完成
* 而且可以多实现(同时实现多个接口),多个接口之间用逗号隔开
* */
//3.创建接口的实现类
class InterImpl implements Inter1,Inter2{
	@Override
	public void update() {
		System.out.println("更新中...");
	}
	@Override
	public void find() {
		System.out.println("查找中...");
	}
	@Override
	public void save() {
		System.out.println("保存中...");
	}
	@Override
	public void delete() {
		System.out.println("删除中....");
	} 
}

七、总结

1. 类与类的关系

        --继承关系 , 只支持单继承

        --比如 ,A 是子类 B 是父类 ,A 具备 B 所有的功能 ( 除了父类的私有资源 )

        --子类如果要修改原有功能 , 需要重写 ( 方法声明与父类一致 + 权限修饰符 >= 父类修饰符 )

2. 类和接口的关系

        --实现关系 . 可以单实现 , 也可以多实现

        --class A implements B,C{}

        --其中 A 是实现类 ,B 和 C 是接口 ,A 拥有 BC 接口的所有功能 , 只是需要进行方法的重写 , 否则 A 就是抽象类

3. 接口与接口的关系

        --是继承关系 , 可以单继承 , 也可以多继承

        --interface A extends B,C{}

        --其中 ABC 都是接口 ,A 是子接口 , 具有 BC 接口的所有功能 ( 抽象方法 )

        --class X implements A{}

        --X实现类需要重写 ABC 接口的所有方法 , 否则就是抽象类

        --class A extends B implements C,D{}

        --其中 A 是实现类 , 也是 B 的子类 , 同时拥有 CD 接口的所有功能

        --这时 A 需要重写 CD 接口里的所有抽象方法

4. 抽象类与接口的区别

        --抽象类是一个特殊的类 , 特殊在 , 抽象类中可以包含没有方法体的方法 ( 抽象方法 )

        --接口是一个特殊的抽象类 , 特殊在 , 接口里的都是抽象方法 , 没有普通方法

        --接口会为方法自动拼接 public abstract, 还会为变量自动拼接 public final static

        --抽象类可以有构造方法 -- 用来给子类创建对象 , 接口没有抽象方法

        --抽象类和接口都不能实例化 ( 创建对象 )

        --抽象类可以有普通方法 , 接口都是抽象方法

八、访问控制符

九、拓展

9.1 abstract 注意事项

9.2 接口和抽象类的区别

最后

以上就是追寻金毛为你收集整理的Java-面向对象基础-6一、抽象类的用法 二、接口 三、接口的用法 四、程序设计 六、接口的多继承多实现 七、总结 八、访问控制符 九、拓展 的全部内容，希望文章能够帮你解决Java-面向对象基础-6一、抽象类的用法 二、接口 三、接口的用法 四、程序设计 六、接口的多继承多实现 七、总结 八、访问控制符 九、拓展 所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。