黑马程序员----java-----继承，接口，多态。

最新推荐文章于 2024-09-04 15:27:21 发布

ly1689511

最新推荐文章于 2024-09-04 15:27:21 发布

阅读量520

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/ly1689511/article/details/45250209

版权

java基础专栏收录该内容

6 篇文章 0 订阅

订阅专栏

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

一，继承：猫继承动物（类与类之间必须有所属关系，父类中的功能子类中都有。）

1，提高代码的复用性。

2，让类与类之间产生了关系，有了这个关系才有了多态。

java中不支持多继承，因为当多个父类中继承了相同的功能时，内容不同，这时不知道运行哪个功能，存在安全隐患。但是java对多继承进行了改良，支持多实现~！

java支持多层继承。（继承体系）想要使用一个类的功能，先查询父类的功能，因为父类的功能是体系中的共性功能。

具体调用时，要创建最子类的对象。（有可能父类不能创建对象或创建子类对象可以使用更多的功能，包括自己的和父类的）。查阅父类功能，创建子类对象。

继承中类成员的调用方法（当创建子类对象时，内存先加载父类字节码文件，再加载子类，然后子类就有了this.与super.俩个引用。）

1，变量：如果子父类中出现了非私有的同名成员变量时，子类要访问本类中的变量，用this，子类要访问父类中的同名变量用super。super与this的使用几乎一致，this代表的是本类对象的引用，super代表的是父类对象的引用。当子类中没有父类同名变量时，操作这个变量时，子类中this就相当于super。

2，函数：当子父类中有同名函数时，子类同名函数覆盖父类同名函数（覆盖，重写），子类对象调用子类的方法。当子类继承父类，沿袭父类的功能到子类中，但是子类虽具备该功能，但子类功能内容与父类的不一致，这时，没有必要定义新功能，而是使用覆盖，保留父类功能定义，并从写功能内容。

覆盖：a，子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。

b，静态只能覆盖静态。（字父类覆盖必须一模一样）

<span style="font-size:18px;"><span style="font-size:18px;">class Fu 
{
	int num = 4；
	void show()
	{
		System.out.println(num);//super 父类
	}
	void speak()
	{
		System.out.println("vb");
	}

}
class Zi extends Fu
{
	int num = 5；
	void speak()
	{
		System.out.println("java");//覆盖,从写内容
	}

	void show()
	{
		System.out.println(super.num);//super 父类
	}
	
}

class ExtendsDemo2
{
	public static void main(String[] args)
	{
		Zi z = new Zi();
		zi.show();
		System.out.println(z.num+"...."+zi.num);
	}
}</span></span>

3,构造函数

在对子类进行对象初始化时,父类的构造函数也会运行.因为在子类构造函数的第一行会有隐示语句super();

子类在调用父类构造函数方式:super(); super()语句一定放在构造函数的第一行.

子类的实例化过程

子类所有的构造函数默认都会访问父类中空参数的构造函数,因为没一个子类的构造函数内第一行都有一句隐式的super();当父类中没有空参数的构造函数时,子类必须手动通过super或者this语句的形式来指定要访问父类中的构造函数.子类的构造函数第一样也可以手动指定this语句来访问本类中的构造函数,子类中至少有一个构造函数会访问父类中的构造函数:

关键字final

final可以修饰类,方法,变量,被final修饰的类不可以被继承,被final修饰的变量是一个常量,只能赋值一次,内部类被定义在局部位置上时,只能访问被final修饰的局部变量.

常量书写规范:所有字母大写,如果由多个单词组成,单词间通过_ 连接.

抽象类:

abstract void ss(); 抽象方法, 抽象方法必须存放在抽象类中:abstract class..;

特点:a,抽象方法一定定义在抽象类中, b,抽象方法和抽象类都必须被abstract关键字修饰.

c,抽象类不可以被创建对象,因为调用抽象方法没有意义d,抽象类中的方法要被使用,必须由子类复写起所有的抽象方法后,建立子类

对象调用,如果子类只覆盖了部分抽象方法,那么这个子类也是一个抽象类.

抽象类可以不定义抽象方法,作用是不让该类建立对象.

类与类之间的关系:了继承, 聚集聚合组合.

练习:假如我们在开发一个系统时需要对员工进行建模,员工包含3个属性,姓名工号和工资,经历也是员工,处理含有员工的属性外,另外还有一个奖金属性,请使用继承的思想设计开发出员工类和经理类.要求类中必要的方法进行属性访问.

<span style="font-size:18px;">abstract class Employee//员工类
{
	private String name;//基本信息
	private String id;
	private double pay;
	
	Employee(String name,String id,double pay)//初始化
	{
		this.name=name;
		this.id=id;
		this.pay=pay;
	}
	public abstract void work();
}
class Manager extends Employee//经理类
{
	private int bonus;
	Manager(String name,String id,double pay,int bonus)//初始化
	{
		super(name,id, pay);//引用父类初始化
		this.bonus=bonus;//自己独有的
		
	}
	public void work()
	{
		System.out.println("Manager work");
	}
}
class Pro extends Employee//普工
{
	Pro(String name,String id,double pay)
	{
		super( name, id, pay);//引用父类初始化
	}
	public void work()
	{
		System.out.println("Pro work");
	}
}</span>

模板方法设计模式:在定义功能时,功能的一部分是确定的,但是有一部分是不确定的,而确定的部分在使用不确定的部分,那么这时,就将不确定的部分暴露出去,由该类的子类去完成.(提高了扩展性与复用性)

获取一段程序运行的时间. 可以解决一类问题.

<span style="font-size:18px;"><span style="font-size:18px;">//currentTimeMillis
//获取时间方法:System.currentTimeMillis();
abstract class GetTime//因为有很多子类需要这个方法,所以建立出来了这个模板
{
	public final void getTime()//final  不让复写。
	{
		 long start = System.currentTimeMillis();
		
		runcode();
		long end = System.currentTimeMillis();
		
		System.out.println("毫秒:"+(end-start));
		
	}
	public abstract void runcode();//抽象方法,或者默认方法,
	
}

class SubTime extends GetTime//继承
{
	public void runcode()//覆盖父类方法
	{
		for(int x=0;x<4000;x++)
		{
			System.out.print(x);
		}
	}
}


class TemplateDemo
{
	public static void main(String[]args)
	{
		SubTime gt = new SubTime();//建立子类对象,
		gt.getTime();//调用子类方法
	}
}</span></span>

二，接口:当抽象类中的方法都是抽象时,该类就可以通过接口的形式表示.

格式:interface 名称 { };

接口不可以被创建对象,因为有抽象方法.需要被子类实现,子类对接口中的方法全部覆盖,子类才可以实例化.

接口中的成员修饰符石固定的:可以省略.

成员变量:public static final

成员函数: public abstract

接口中的成员都是被public修饰的.

接口的出现将"多继承"通过另外一种形式体现出来,即"多实现"

类与接口的关系:implements ( 实现 )

java支持单继承加多实现.弥补了不能多继承. 接口之间支持多继承,

接口的特点:

继承与实现的区别, 继承是is a, 接口是可以是其中的一个,(扩展).

三，多态:可以理解为事物存在的多种体现形态。一个对象变量可以指向多个实际类型的对象。

1，多态的体现，

Animal c = new Cat（）;这个里面存在着类型提升，把Cat提升为了Animal。向上转型，

父类的引用指向自己的子类对象。（父类的引用也可以接受自己子类的对象）

2，多态的前提

必须是类与类之间有关系（继承或实现）

通常存在覆盖。

3，多态的好处

提高了程序的扩展性

4，多态的弊端

只能使用父类的引用访问父类的成员

5，多态的应用

6，多态吃的出现代码中的特点（注意事项。）

Animal c = new Cat（）;这个里面存在着类型提升，把Cat提升为了Animal。向上转型，

Cat c= (Cat)c; 将c强转成动物，向下转型。

关键字 instanceof 判断某一类型引用是否属于该类型。。 c instanceof cat ，c是否属于cat。

多态的应用：

abstract class Student
{
	public abstract void study();
	public void sleep()
	{
		System.out.println("躺着睡");
	}
}
class DoStudent
{
	
	public void doSome(Student stu)//这里接收Student子类  完成多态，提高扩展
	{
		stu.study();
		stu.sleep();
	}
}//以上是固有类，前期  下面是以后可以添加，

class BaseStudent extends Student
{
	public void study()
	{
		System.out.println("base study");
	}
	public void sleep()
	{
		System.out.println("坐着睡");
	}
}

class AdvStudent extends Student
{
	public void study()
	{
		System.out.println("adv study");
	}
}

class DuoTaiDemo
{
	public static void main(String[]args)
	{
		DoStudent ds = new DoStudent();
		ds.doSome(new BaseStudent());//
		ds.doSome(new AdvStudent());
	}
	
}

多态的特点：

<span style="font-size:18px;">class Fu
{
	int num = 5;
	void method1()
	{
		System.out.println("fu method1");
	}
	void method2()
	{
		System.out.println("fu method2");
	}
	static void method4()
	{
		System.out.println("fu method4");
	}
}

class Zi extends Fu
{
	
	int num =8;
	
	void method1()
	{
		System.out.println("zi method1");
	}
	void method3()
	{
		System.out.println("zi method3");
	}
	static void method4()
	{
		System.out.println("zi method4");
	}
}

class DuoTaiDemo4
{
	public static void main(String[]args)
	{
		Fu f = new Zi();
		
		f.method4();
		/*
		在多态中，静态成员函数的特点：
		无论编译和运行，都参考左边。   
		因为在子父类加载进内存时，   子父类的方法都已经存在于内存中的方法区，静态的方法绑定
		在了其所属的类上，  f.method4  就相当于 Fu.method4
		
		非静态是动态绑定。
		
		
		静态只参考引用所属。
		*/
		
		
		
		
		//Fu f = new Zi();
		
		
		//System.out.println(f.num);
		
		/*
		在多态中，成员变量的特点：
		当多态中子父类中出现同名变量时，无论编译还是运行时期，都看左边。
		
		
		
		*/
		
		//Zi z = new Zi();
		
		//System.out.println(z.num);
		//f.method1();
		//f.method2();
		
		
		//f.method3();  //非静态，，，编译时期不能通过，因为在编译时期父类中不存在这个方法。
		/*
		在多态中成员函数的特点：在编译使其，参阅引用型变量所属的类中是否有调用的方法，
		
		如果由则编译通过，如果没有编译失败，
		
		在运行时期：参阅对象所属的类中是否有调用的方法。
		
		成员函数在多态调用时期，编译看左边，运行看右边。
		
		
		
		
		*/
		
		
		
		
		
		/*
		Zi z = new Zi();
		z.method1();
		z.method2();
		z.method3();
		
		
		*/
		
	}
}</span>

主板示例：

interface PCI//接口
{
	public void open();
	public void close();
}

class MainBoard//主板
{
	
	public void run()
	{
		System.out.println("mainboard run");
	}
	public void usePCI(PCI p)
	{	
		if(p!=null)
		{
			p.open();
			p.close();
		}
		
	}
}

class NetCard implements PCI//网卡插入PCI
{
	public void open()
	{
		System.out.println("netcard open");
	}
	public void close()
	{
		System.out.println("netcard close");
	}
}
class SoundCard implements PCI//声卡插入PCI
{
	public void open()
	{
		System.out.println("SoundCard open");
	}
	public void close()
	{
		System.out.println("nSoundCard close");
	}
}
class DuoTaiDemo5//开启
{
	public static void main(String[]args)
	{
		
		
		MainBoard mb = new MainBoard();
		mb.run();
		mb.usePCI(null);
		mb.usePCI(new NetCard());
		mb.usePCI(new SoundCard());
	}
}

Object类：是所有对象的直接或者间接父类。

该类中定义了所有对象具备的功能。

功能：

equals（Object obj）：将俩个对象进行比较。

如果父类中定义的比较功能不是所需要的，这样自己复写父类的方法equals 创建自己的比较方法。

toString（）：将对象转换成字符串。（对象所属类名+@+哈希值）

hashCode（）：返回该对象的哈希值。

getMethods（）：获取字节码文件所有方法。