黑马程序员-JAVA基础-继承、抽象、接口

最新推荐文章于 2024-03-14 20:49:58 发布

丢物线

最新推荐文章于 2024-03-14 20:49:58 发布

阅读量418

点赞数

本文链接：https://blog.csdn.net/lmxfxm/article/details/46923829

版权

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、继承

1.概念：多个类中具有相同的属性和行为时，可以将相同的属性和行为提取出来放在单独一个类中，多个类就可以继承这个类，而不再需要定义这些属性和行为。多个类称为子类，单独一个类称为父类或超类。子类可以直接访问父类中非私有属性和行为。

2.好处：提高代码复用性；继承的出现让类与类之间产生关系，提供多态的前提。

例如：学生和工人都具有姓名和年龄，但是学生有学习功能，工人有工作功能，这是就可以将姓名和年龄提取出来

class Person
{
	int age;//共性属性年龄
	String name;//共性属性姓名
}
class Student extends Person
{
	public void study()
	{
		System.out.println("姓名："+this.name+"年龄："+this.age+"---学习");//特有学习方法
	}
}
class Worker extends Person
{
	public void work()
	{
		System.out.println("姓名："+this.name+"年龄："+this.age+"---工作");//特有工作方法
	}
}
class ExtendsDemo
{
	public static void main(String[] args) 
	{
		Student s = new Student();
		s.age = 21;
		s.name = "lee";
		s.study();

		Worker w = new Worker();
		w.age = 30;
		w.name = "lisi";
		w.work();
	}
}

3.特点：只支持单继承，支持多层继承

3.1子父类中变量的特点：子父类中存在相同的成员变量时，用this调用子类变量，用super调用父类变量。

class Fu
{
	int num = 2;
}
class Zi extends Fu
{
	int num = 6;
	void show()
	{
		System.out.println(this.num);//访问子类num
		System.out.println(super.num);//访问父类num
	}
}
class ExtendsDemo 
{
	public static void main(String[] args) 
	{
		Zi z = new Zi();
		z.show();
	}
}

3.2子父类中函数的特点：

覆盖：子类中有跟父类一模一样的函数，这就是覆盖。注意：父类的私有方法不能被覆盖；子类方法权限一定要大于父类的方法权限；静态只能覆盖静态。

应用：当子类要沿袭父类功能时，但子类又有自己的特有内容，这时就可以进行覆盖，可以通过super关键字访问父类的方法。

例如：手机以前只能显示电话号码和姓名，在更新换代后，不仅可以显示号码和姓名，还可以显示头像和归属地。

class Phone
{
	void show()
	{
		System.out.println("姓名");
		System.out.println("电话号码");
	}
}
class newPhone extends Phone
{
	void show()
	{
		super.show();
		System.out.println("归属地");
		System.out.println("头像");
	}
}
class ExtendsDemo2 
{
	public static void main(String[] args) 
	{
		newPhone p = new newPhone();
		p.show();
	}
}

3.3子父类中构造函数的特点：

子类的所有构造函数都会访问父类中的空参数构造函数。原因：子类要先知道父类是如何初始化父类中的数据

子类所有的构造函数的第一行都有一条隐式的super();

当父类中没有空参数构造函数时，子类必须通过super语句来指定要访问父类中哪个构造函数。

子类中也可以通过this语句要指定访问本类中的构造函数。

class Fu
{
	Fu()
	{
		System.out.println("父类运行");
	}
}
class Zi extends Fu
{
	Zi()
	{
		System.out.println("子类运行");
	}
}
class ExtendsDemo3 
{
	public static void main(String[] args) 
	{
		//super(); 隐式的super语句
		Zi z = new Zi();//父类运行
			<span style="white-space:pre">	</span>//子类运行
	}
}

4. final关键字：

(1)可以修饰类、变量、方法
(2)被修饰的类不可以被继承
(3)被修饰的方法不可以被复写
(4)被修饰的变量是一个常量，只能赋值一次。便于阅读，变量名称都应大写、由多个单词组成，用_连接

(5)内部类定义在类的局部位置时，只能访问局部位置被final修饰的局部变量

二、抽象

1、概念：当多个类中出现相同的功能，但功能主体不同时，可以将相同的功能抽取出来放在一个类中，这是功能没有明确主体，调用没有意义，

可以用abstract关键字修饰，同时这个类也要用abstract修饰。

例如：猫和狗都会叫，但猫是“喵喵叫”，狗是“汪汪叫”，这是叫的功能就可以抽取出来放在一个动物类中

abstract class Animal{
	//定义抽象的叫方法
	public abstract void shout();
}
//定义一个猫类
class Cat extends Animal{
	
	//猫特有的叫方法
	public void shout() {
		System.out.println("喵喵叫");
	}
}
//定义一个狗类
class Dog extends Animal{

	//狗特有的叫方法
	public void shout() {
		System.out.println("汪汪叫");
	}
}

2、特点：

(1)抽象方法一定在抽象类中
(2)抽象方法和抽象类都要用abstract修饰
(3)抽象类不能用new创建对象
(4)抽象类中的抽象方法要被使用，必须由子类覆盖所有抽象方法，创建子类对象调用。
(5)如果子类只是覆盖一部分抽象方法，那么子类还是抽象类

3、注意事项：

（1）抽象类中是否有构造函数?

有，因为抽象类是父类，要给子类提供实例初始化

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

final关键字，被final修饰的类不能被继承。

private关键字，被private修饰，子类就不知道父类的功能，无法进行复写

static关键字，在抽象类中可以直接被调用，没有存在的意义。

4、练习

/*
假如我们在开发一个系统时需要对员工进行建模，员工包含 3 个属性：
姓名、工号以及工资。经理也是员工，除了含有员工的属性外，另为还有一个
奖金属性。请使用继承的思想设计出员工类和经理类。要求类中提供必要的方
法进行属性访问
*/
abstract class Employee
{
	private int id;//工号属性
	private String name;//姓名属性
	private double pay;//工资属性

	public void setId(int id)
	{
		this.id = id;
	}
	public int getId()
	{
		return id;
	}
	public void setName(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return name;
	}
	public void setPay(double pay)
	{
		this.pay = pay;
	}
	public double getPay()
	{
		return pay;
	}

	//具有工号、姓名、工资的构造函数
	public Employee(int id,String name,double pay)
	{
		this.id = id;
		this.name = name;
		this.pay = pay;
	}

	public abstract void work();//抽象的工作方法
}
class Manager extends Employee
{
	private double bonus;//奖金属性
	public void setBonus(double bonus)
	{
		this.bonus = bonus;
	}
	public double getBonus()
	{
		return bonus;
	}

	//具有工号、姓名、工资、奖金的构造函数
	public Manager(int id,String name,double pay,double bonus)
	{
		super(id,name,pay);//调用父类构造方法
		this.bonus = bonus;
	}

	public void work()
	{
		System.out.println("经理工作");
	}
}
class AbstractTest 
{
	public static void main(String[] args) 
	{
		Manager m = new Manager(1,"lee",5000.00,1000.00);
		m.work();
	}
}

5、模板方法设计模式：当定义功能时，有一部分功能是确定的，但是有一部分功能没有确定，并且已经确定的功能要使用到没有确定的功能

这时可以将不确定的功能暴露出去给子类实现。

例如：

/*
定义一个类，里面有一个获取代码运行时间的功能
分析：获取时间的功能是确定的，但是获取哪些代码运行的时间是不确定的
可以将代码提取出来，由子类去完成
*/
abstract class getTime
{
	public final void getTime()
	{
		long start = System.currentTimeMillis();

		runCode();

		long end = System.currentTimeMillis();
		System.out.println(start-end);
	}

	public abstract void runCode();
}
class subTime extends getTime
{
	public void runCode()
	{
		for (int i=0; i<2000; i++)
		{
			System.out.print(i);
		}
	}
}
class Template
{
	public static void main(String[] args) 
	{
		subTime st = new subTime();
		st.getTime();
	}
}

三、接口（interface）
1.接口中成员的修饰符是固定的

成员变量：public static final

成员函数：public abstract

2.特点：

接口是对外暴露的规则
接口是程序的扩展
接口降低程序的耦合性
类可以实现多个接口，这就是多实现
接口与接口之间可以继承，并且可以多继承