黑马程序员笔记——Java面向对象之继承

----------- android培训、java培训、java学习型技术博客、期待与您交流！ -----------

继承

继承概述

多个类中存在相同属性和行为时，将内容抽取到单独一个类中

其他类无需再定义这些属性和行为，只要继承单独的那个类即可

通过extends关键字完成继承      例子：class Student extends Demo{}

继承的好处：

提高了代码的复用性

让类与类之间产生了关系，提供了多态的前提

java只支持单继承，不支持多继承（接口支持多继承）

原因：

多继承容易带来安全隐患，当多个父类中定义了相同功能，当功能内容不同时，

子类对象不确定要运行哪一个

注意：

不要为了获取其他类中某个功能而去继承

类与类之间要有所属（”is  a“）关系，xx1是xx2的一种。

但是Java中保留这种机制。并用另一种形式来完成表示，多实现

Java支持多层继承，也就是一个继承体系。

如何使用父类继承体系中的功能

先查阅体系父类中 定义的共性功能，以了解体系的基本功能，

创建子类对象，使用功能

为什么要创建子类对象调用功能

一是因为 有能父类不能创建对象。

二是创建子类对象可以使用更多的功能，包括基本的也包括特有的

子父类出现后，类成员的特点

类中成员：

1、变量。2、函数。3、构造函数。

变量

如果子类中出现非私有的同名变量时

子类要访问本类中的变量，用this

子类要访问父类中的同名变量，用super

super的使用和this的使用几乎一致

this代表的是本类对象的引用

super代表的是对父类对象的引用

 函数

当子类出现和父类一模一样的函数时

子类对象调用该函数，会运行子类函数的内容

如同父类的函数被覆盖一样

这种情况是函数的另一特性：重写

当子类继承父类，沿袭了父类的功能，到子类中，但是子类虽具备该功能，

但是功能的内容却和父类不一致，这时，没有必要定义新功能，而是使用覆盖特殊，

保留父类的功能定义，并重写功能内容。

覆盖：

1、父类的私有方法不可以被覆盖 

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

3、静态之鞥覆盖静态。静态不能覆盖非静态。

class Fu
{
	void show()
	{
		System.out.println("fu show");
	}
	void speak()
	{
		System.out.println("vb");
	}
}

class Zi extends Fu
{
	void speak()
	{
		System.out.println("java");
	}
	void show()
	{
		System.out.println("zi show");
	}
}
class ExtendsDemo3 
{
	public static void main(String[] args) 
	{
		Zi z = new Zi();
		z.speak();

	}
}

构造函数

子类中的构造函数

在对子类中的构造函数初始化时，父类的构造函数也会运行，

那是因为之类的构造函数默认第一行有一条隐式的语句 super（）

super（）：

会访问父类中空参数的构造函数，而且子类中的所有构造函数默认第一行都有super()

为什么子类一定要访问父类中的构造函数

因为父类中的数据子类可以直接获得，所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的

所以子类在些对象初始化时，要先访问一下父类的构造函数

如果要访问父类中指定的构造函数，可以通过手工定义super语句的方式来指定

注意：super语句一定定义在子类构造函数的第一行

当然：子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。

子类中至少会有一个构造函数会访问父类中的构造函数。

class Fu //extends Object
{
	int num ;
	Fu()
	{
		//super();
		num= 60;
		System.out.println("fu run");
	}
	Fu(int  x)
	{
		System.out.println("fu ...."+x);
	}
	
}

class Zi extends Fu
{
	Zi()
	{
		
		super();  
		//super(4);
		System.out.println("zi run");
	}
	Zi(int x)
	{
		this();
		//super();
		//super(3);
		System.out.println("zi..."+x);
	}
}

class  ExtendsDemo4
{
	public static void main(String[] args) 
	{
		Zi z = new Zi(0);
		System.out.println(z.num);
	}
}

/*
class Person
{
	private  String name;
	Person(String name)
	{
		this.name = name;
	}

	void show(){}
}
class Student extends Person
{
	Student(String name)
	{
		super(name);
	}
	void method()
	{
		super.show();
	}
}
*/

final

final的作用：

最终，作为一个修饰符

1、可以修饰类、函数、变量

2、被final修饰的类不可以被继承。为了避免被继承，被子类复写功能。

3、被final修饰的方法不可以别复写

4、被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，也可以修饰局部变量。

      当字啊描述事物时，一些数据的出现指示固定的，那么这时为了争强阅读性，都给这些值起个名字方便阅读

      而这个值不需要改变，所以加上final修饰，作为常量：常量的书写规范所有字母都大写，多个单词用下划线隔开

5、内部类定义在类中局部位置上，只能访问该局部被final修饰的局部变量

类的修饰符：

public和final

class Demo
{
	final int x = 3;
	public static final double PI = 3.14;
	final void show1()
	{}
	void show2()
	{
		final int y = 4;
		System.out.println(3.14);
	}
}
class SubDemo extends Demo
{
	//void show1(){}
}
class FinalDemo 
{
	public static void main(String[] args) 
	{
		System.out.println("Hello World!");
	}
}

抽象类

抽象类的应用

当多个类中出现相同功能，但是功能主体不同，

这是可以进行向上抽取。这时，只抽取功能定义，而不抽取功能主体。

抽象类的特点：

1、抽象方法一定在抽象类中。

2、抽象方法和吃哦想类都必须被abstract修饰。

3、抽象类不可以用new 创建对象，因为滴哦用抽象方法没意义

4、抽象类中的抽象方法要被使用，必须由子类复写所有抽象方法后，建立子类对象调用

       如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类

抽象类比一般类多了抽象函数，就是在类中可以定义抽象方法抽象类不可以实例化。

5、抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

abstract关键字和那些关键字不能共享

1、final：被final修饰的类不能有子类，而被abstract修饰的类一定是一个父类。

2、private：抽象类中的私有的抽象方法，不能被子类所知，就无法被复写

      而抽象方法出现的就是需要被复写

3、static：如果static可以修饰抽象方法，那么连对象都省了，直接类名调用就可以了，

      可是抽象方法运行没意义。

抽象类中是否有构造函数？

有，抽象类是一个父类，要给子类提供实例的初始化。

*/

abstract class Student
{
	abstract final void study();
	//abstract void study1();
	void sleep()
	{
		System.out.println("躺着");
	}
}
/*

class ChongCiStudent extends Student
{
	void study()
	{
		System.out.println("chongci study");
	}
}

class BaseStudent extends Student
{
	void study()
	{
		System.out.println("base study");
	}
}

class AdvStudent extends Student
{
	void study()
	{
		System.out.println("adv study");
	}
}
*/
class AbstractDemo 
{
	public static void main(String[] args) 
	{
		//new Student();
		//new BaseStudent().study();
	}
}

模板方法模式

在定义功能时，功能的一部分是确定的，但是有用一部分是不确定的，

而确定的部分在使用不确定的部分

那么这是就将不确定的部分暴露出去，由该类的子类去完成。

/*
需求：获取一段程序运行的时间。
原理：获取程序开始和结束的时间并相减即可。

获取时间：System.currentTimeMillis();

当代码完成优化后，就可以解决这类问题。

这种方式，模版方法设计模式。

*/

abstract class GetTime
{
	public final void getTime()
	{
		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) 
	{
		//GetTime gt = new GetTime();
		SubTime gt = new SubTime();
		gt.getTime();
	}
}

接口

interface概述：

初期理解，可以认为是一个特殊的抽象类

当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示

class用于定义类

interface用来定义接口

接口定义时格式特点：

1、接口中常见定义：常量，抽象方法

2、接口中的成员都有固定修饰符。

常量：public static final

方法：public abstract    可以省略不写，虚拟机会自动加上。

记住：接口中的成员都是public的。

接口的特点：

1、接口是对外暴露的规则。

2、接口是程序的功能扩展。

3、接口可以用来多实现。

4、类与接口之间是实现关系，而且类可以继承一个的同时实现多个接口。

5、接口与接口之间可以有继承关系。

例子：主板的pci接口。插座。笔记本电脑的usb接口。

类与类之间是继承关系。
类与接口之间是实现关系。用implements连接
接口与接口之间是继承关系，而且，接口之间存在多继承。

 

接口：是不可以创建对象的，因为有抽象方法。需要被子类实现，子类对接口中的抽象方法全都覆盖后，

    子类才可以实例化。否则子类是一个抽象类

接口可以被类多实现，也是对多继承不支持的转换形式，Java支持多实现。

interface Inter
{
	public static final int NUM = 3;
	public abstract void show();
}

interface InterA
{
	public abstract void show();
}

class Demo
{
	public void function(){}
}

class Test extends Demo implements Inter,InterA
{
	public void show(){}
}


interface A
{
	void methodA();
}
interface B //extends A
{
	void methodB();
}

interface C extends B,A
{
	void methodC();
}

class D implements C
{
	public void methodA(){}
	public void methodC(){}
	public void methodB(){}
}


class InterfaceDemo 
{
	public static void main(String[] args) 
	{
		Test t = new Test();
		System.out.println(t.NUM);
		System.out.println(Test.NUM);
		System.out.println(Inter.NUM);

	}
}

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------