Java复习之路（第九天面向对象）（多态成员特点，抽象类，接口）

最新推荐文章于 2020-02-04 21:33:23 发布

Anoxia_Tian

最新推荐文章于 2020-02-04 21:33:23 发布

阅读量135

点赞数

分类专栏： Java基础

本文链接：https://blog.csdn.net/qq_38214552/article/details/103750888

版权

Java基础专栏收录该内容

34 篇文章 0 订阅

订阅专栏

Java基础

多态的成员使用特点：

1.成员变量：使用的是父类的

2.成员方法：由于存在重写现象所以使用的是子类的

3.静态成员：随着对象而存在，谁调用的就返回谁的

测试：

成员方法：由于存在重写现象所以使用的是子类的

		//创建多态的对象
		//父类引用指向子类的对象
		Father father=new Son();
		//编译看左边，运行看右边
		//子类在干活，输出的是儿子的eat的方法
		//多态的方法的使用，能够用什么方法看父类，执行的效果是看子类
		//如果子类发生了重写，执行效果就是重写以后得效果
		father.eat();

成员变量：使用的是父类的

		
		int a=father.num;
		System.out.println(a);
		
	}
}
//前提一：继承
//前提二：重写方法
class Father{
	int num=10;
	public  void eat() {
		System.out.println("父亲在吃饭");
	}
}

class Son extends Father{
	int num=20;
	public  void eat() {
		System.out.println("儿子也想吃饭");
	}
}

静态成员：随着对象而存在，谁调用的就返回谁的

//静态的资源的使用，就是谁调用就是谁的
		int count =father.count;
		System.out.println(count);
		
	}
}
//前提一：继承
//前提二：重写方法
class Father{
	static int count =10;
	int num=10;
	public  void eat() {
		System.out.println("父亲在吃饭");
	}
}

class Son extends Father{
	static int count =20;
	int num=20;
	public  void eat() {
		System.out.println("儿子也想吃饭");
	}
}

总结：

1.多态的方法的使用，能够用什么方法看父类，执行的效果是看子类,如果子类发生了重写，执行效果就是重写以后得效果

2.成员变量的使用：多态中只有调用父类的调用的功能，所以用的就是父类的num'的属性

3.静态的资源的使用，就是谁调用就是谁的

抽象类

定义：Java中可以定义没有方法体的方法，该方法是由期子类来具体的实现，该方法没有方法体的方法我们称之为抽象方法，含有抽象方法的类我们抽象类，抽象类可以理解为是一个只有方法声明没有方法体的特殊的类

修饰符：abstract 返回值方法名称（参数的列表）

特点：

1.通常Java关键字abstract实现 abstract class Person

2.可以修饰方法或者类 abstract class void eat （）

3.抽象类中的可以没有抽象方法（由他的子类进行实现）

4.如果类中有抽象方法，那该类就必须定义为一个抽象的类

5.子类继承了抽象以后，要么还是一个抽象类，要么就把所有的抽象方法都重写

6.多用于多态

7.抽象类不可以被实例化（不可以进行new出来对象）

方法的使用的条件，就是子类都具有这个功能，但是这个方法的内容不太一样，所以进行创建抽象类进行实现继承实现不了功能

继承：把子类的共有的功能，向上提取到父类中

抽象类：当子类继承父类后，子类可能需要重写，这是父类的实现就没用会被覆盖

入门案例

package com.tedu.oop;
//测试抽象类的用法
public class Test3_Abstract2 {
	public static void main(String[] args) {
		Father3 father3=new Son3();
		
	}
}

 abstract class Father3{
	 //总结一：抽象类自己是不能进行创建对象的
	 //因为子类创建对象时会调用构造函数中的super()
	 //那抽象类中的构造的方法用来给子类进行创建对象
	 
	 //抽象类中的构造方法的使用
	public Father3() {
		System.out.println(1);
	}
}

class Son3 extends Father3{
	public  Son3() {
		//过程会自动的生成super()的方法
		super();
		System.out.println(2);
	}
}

成员变量：

既可以有变量，也可以有常量

package com.tedu.oop;
//测试抽象类中的成员变量的使用
public class Test4_Abstract3 {
	public static void main(String[] args) {
		Father4 father4 =new Son4();
		System.out.println(father4.name);
		System.out.println(father4.name1);
		System.out.println(father4.name2);
	}
}
//总结2：在抽象类中可以有变量也可以有常量
 abstract class Father4{
	 String name;     //变量
	 String name1="大黄";      //变量
	 final String name2="大黄";      //常量
	 
}
 class Son4 extends Father4{
	 
 }

成员方法:

抽象类里面机会可以有普通的方法，也可以有常用的方法

package com.tedu.abstractdemo;
//测试抽象类里面的方法
public class Test5_Abstract4 {
	public static void main(String[] args) {
		//抽象类不可以进行创建对象，就是不可以进行实例化对象（）new出来的对象
		//创建多态的对象
		Father5 father5=new Son5();
		father5.eat();
		father5.sleep();
		//创建子类的对象
		Son5 son5=new Son5();
		son5.eat();
		son5.sleep();
	}
}
abstract class Father5{
	//普通的方法
	public void eat() {
		System.out.println("父类在吃饭");
	}
	//抽象的方法
	public abstract void sleep();
}
class Son5 extends Father5{
	//重写抽象的方法
	public void sleep() {
		System.out.println("子孙在睡觉");
	}
}

分析老师的实例：

实现的功能：

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

共性：姓名，年龄，讲课，备课

测试：创建多态对象执行的方法

package com.tedu.abstractdemo;
//分析老师的实例
public class Test6_Teacher {
	public static void main(String[] args) {
		Teacher teacher=new PeiYouTeacher();
		//利用多态的形式进行创建对象
		teacher.BeiKe();
		teacher.Jiangke();
		teacher.name="培优老师";
		teacher.age=29;
		System.out.println(teacher.age);
		System.out.println(teacher.name);
		//利用继承的思想进行创建方法
		GaoShouTeacher gaoShouTeacher=new GaoShouTeacher();
		gaoShouTeacher.Jiangke();
		gaoShouTeacher.BeiKe();
		gaoShouTeacher.age=20;
		gaoShouTeacher.name="高手老师";
		System.out.println(gaoShouTeacher.age);
		System.out.println(gaoShouTeacher.name);
	}
}
 abstract class Teacher{
	String name;
	int age;
	
	public void BeiKe() {
		System.out.println("老师在备课");
	}
	public abstract void Jiangke();	
}
 
 class PeiYouTeacher extends Teacher{
	 public void Jiangke() {
		System.out.println("培优老师讲培优课程");
	}
 }
 class GaoShouTeacher extends Teacher{
	 public void Jiangke() {
		System.out.println("高手老师讲培优课程");
	}
 }

接口

Java里面由于不允许多重的继承，所以如果要实现多类的功能，则可以通过实现多个接口来实现，

Java接口和Java的抽象类代表的就是抽象的类型，就是我们需要提出的抽象的具体的oop面向对象的编程，如果想要提高代码的重用率，增加对象的可维护性，可扩展性，必须是面向接口的编程，正确的实用接口抽象类这些太有用的抽象类为Java结构层次上的顶层

代码的形式：inferface 接口名 {代码。。。。。}

接口的使用

1.接口中都是抽象的方法

2.通过interface关键字进行创建接口

3.通过implement让子类和接口实现的关系

4.可以进行理解为，接口是一个特殊的抽象类

5.接口突破了Java的单继承的局限性

6.接口和类之间可以多实现,接口和接口之间可以进行多继承

7.接口是对外暴露的规则，是一套开发的规范

8.提高了接口的程序的功能的扩建，降低了耦合性

接口的入门案例

package com.tedu.abstractdemo;
//测试接口的 入门的案例
public class Test7_Interface{
	public static void main(String[] args) {
		//进行测试子类实现的功能
		Father7 father7=new Son7();
		father7.eat();
		father7.run();
	}
}
//定义接口 interface定义的关键字
interface  Father7{
	//定义抽象的方法,接口里面都是抽象的方法
	abstract public void eat();
	abstract public void run();
}
//定义子类进行实现父类的方法
class Son7 implements Father7{
	public void eat() {
		System.out.println("实现吃的功能");
	}
	public void run() {
		System.out.println("实现跑的功能");
	}
}

@Override //代表的是重写 @代表得是注解

接口的用法

1.接口里面不可以进行定义构造方法

接口里面是没有构造方法的，在创建实现类的对象时默认的super（）,是调用的默认的Object中的无参构造

2.成员的变量

接口里面没有成员的变量，都是常量，所以，你定义一个变量没有写上修饰符号的时候，默认的会加上public static final

父类进行赋值，儿孙不能进行更改，说明这个变量是常量，可以由方法进行直接的进行调用，说明这个变量是静态的

3.成员方法

接口里面的方法，默认的都是抽象的情况，如果你写的不是abstract的，就会自动进行给你补齐

例如：abstract void save

package com.tedu.intefacedemo;
//测试接口的用法
public class Test8_Interface2 {
	public static void main(String[] args) {
		Father8 father8=new Son8();
		//father8.name="熊二";   3.接口里面都是常量
		//4.接口里面的变量都还是静态的可以进行通过类名进行调用
		System.out.println(father8.name);
	}
}
//定义接口
interface Father8{
	//1.接口里面不可以进行定义构造方法
	//public father() {	}
	//2.接口里面没有成员的变量，都是常量
	//he final field Father8.name cannot be assigned
	String name="熊大";
	
	
}
class Son8 implements Father8{
}

知识点进行总结：

类和类，类和接口，接口和接口之间的关系：