黑马程序员——继承、抽象

---------------------- 黑马程序员 Android培训、期待与您交流！ ----------------------

继承的概述

1.        多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行 为，只要继承单独的那个类即可。

2.        多个类可以称为子类，单独这个类称为父类或者超类。

3.        子类可以直接访问父类中的非私有的属性和行为。

4.        通过extends 关键字让类与类之间产生继承关系。

• class SubDemo extends Demo{}

 继承的出现提高了代码的复用性。

 继承的出现让类与类之间产生了关系，提供了多态的前提。

继承的特点

Java只支持单继承，不支持多继承。

• 一个类只能有一个父类，不可以有多个父类。

• class SubDemo extends Demo{} //ok

• class SubDemo extends Demo1,Demo2...//error

定义继承需要注意：

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

• 类与类之间要有所属(" is a " )关系，xx1是xx2的一种。

super关键字

l        super代表父类引用

l        当子父类出现同名成员时，可以用super进行区分

l        子类要调用父类构造函数时，可以使用super语句。

函数覆盖

父类中的私有方法不可以被覆盖。

 

覆盖注意事项：

• 覆盖时，子类方法权限一定要大于等于父类方法权限

• 静态只能覆盖静态。

覆盖的应用：

• 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内 容。

继承的特点

/*
 * 将学生和工人的共性描述提出出来，单独进行描述
 * 只要让学生和工人与单独描述的这个类有关系，就可以了。
 * 
 * 继承：extends
 * 1，提高代码的复用性
 * 2，让类与类之间产生的关系。有了这个关系才有了多态的特性
 * 
 * 注意：千万不要为了获取其它类的功能，简化代码而继承
 *       必须是类与类之间所属关系才可以继承。所属关系   is a 。
 *       
 *       
 * class Demo1
 * {
 * 		void demo1(){}
 * }
 * class Demo2 extends Demo1
 * {
 * 		void demo2(){}
 * }
 * class Demo3 extends Demo1
 * {
 * 		void demo3(){}
 * }
 *  Java语言中，Java只支持单继承，不支持多继承
 *  （因为多继承容易带来安全隐患）当父类中定义了相同功能，
 *  但功能内容不同时，子类对象不确定要运行哪一个。
 *  
 *  但Java保留了这种机制。并用另一种体现形式来完成表示。多实现。
 *  
 *  如何使用一个继承体系中的功能呢？
 *  要使用体系，首先查阅体系父类的描述，因为父类定义的是该体系中的共性功能
 *  通过了解共性功能，就能知道该体系的基本功能。
 *  那么这个体系已经可以基本使用了。
 *  
 *  那么在调用时，要创建最子类的对象。。为什么呢？
 *  一是。因为有可能父类不能创建对象。
 *  二是。创建子类对象可以使用更多的功能。包括基本的，也包括特有的。
 *  
 *  简单一句话；查阅父类功能，	创建子类对象使用功能。
 */
class Person
{
	String name;
	int age;
}

class Worker extends Person
{
	void work()
	{
		System.out.println("worke");
	}
}
public class _01继承 {
	
	public static void main(String[]args)
	{
		Worker k = new Worker();
		k.name="张三";
		k.age=22;
		k.work();
		System.out.println("姓名："+k.name+"，年龄："+k.age);
	}
}

子父类变量的特点

/*
 * 子父类出现后，类成员的特点：
 * 
 * 类中成员。
 * 1，变量。
 * 2，函数。
 * 3，构造函数。
 * 
 * 1，变量：
 * 如果子类中出现非私有变量的同名成员变量时，
 * 子类要访问本类中的同名变量，用this
 * 子类要访问父类中的同名变量，用super
 * 
 * super的使用和this的使用几乎一致。
 * this代表本类对象的引用。
 * super代表父类对象的引用。
 * 
 * 2，子父类中的函数
 * 当子类和父类出现一模一样的函数时，
 * 当子类对象调用该函数，会运行子类函数的内容。
 * 如同父类的函数被覆盖一样。
 * 
 * 这种情况是函数的另外一个特性：重写（覆盖）
 * 但子类虽然具备该功能，但是功能的内容却和父类不一致。
 * 这时，没有必要定义新的功能，而是使用覆盖特性，保留父类功能的定义，并重写功能内容。
 * 
 * 覆盖：
 * 1,子类覆盖父类，必须保证子类权限〉＝父类权限，否则编译失败
 * 2,静态只能覆盖静态
 * 
 * 记住大家：
 * 重载：只看同名函数的参数列表。
 * 重写：子父类方法要一模一样。
 * 
 * 我们已经知道的三种权限：
 * public 最大访问权限
 * private 个人内部访问权限
 * void 访问权限介于public和private之间
 */

class Fu
{
	int num =4;
	void Show()
	{
		System.out.println("父类方法");
	}
	void Speak()
	{
		System.out.println("vb");
	}
}
class Zi extends Fu
{
	int num=5;
	void Show()
	{
		System.out.println("子类方法"+super.num);//super是指调用父类的变量值
	}
	void Speak()
	{
		System.out.println("Java");
	}
}
public class _02子父类变量的特点 {
	
	public static void main(String[]args)
	{
		Zi z = new Zi();
		z.Show();
	}

}

/*
 * 子父类中的构造函数。
 * 在对子类对象进行初始化时，父类对象的构造函数也会运行。
 * 那是因为子类的构造函数默认第一行有一条隐式的语句：super();
 * super();会访问父类空参数的构造函数。而且子类中所有的构造函数默认第一行都是super();
 * 
 * 为什么子类一定要访问父类中的构造函数。
 * 因为父类中的数据子类可以直接获取。所以子类对象在建立时，
 * 需要先查看父类是如何对这些数据进行初始化的
 * 所以子类在对象初始化时，要先访问一下父类中的构造函数。
 * 如果要访问父类中的构造函数，可以通过手动定义super语句的方式来指定。。。
 * 
 * 注意：super语句一定要定义在子类构造函数的第一行。
 *      如果第一行是this();那么默认的super();语句将被替代掉。他俩只能活一个
 *      
 * 结论：
 *      子类的所有构造函数，默认都会访问父类的空参构造函数。
 * 因为：子类的所有构造函数第一行，都存在一个隐式的super();语句。
 * 当父类中没有空参数的构造函数时，子类必须手动通过super形式来指定访问父类中的构造函数。 
 * 当然：子类的构造函数第一行，也可以手动指定this语句来访问本类中的构造函数。
 *       子类中至少会有一个构造函数来访问父类中的构造函数。
 * 
 */
class FuLei
{
	int num;
	FuLei()
	{
		int num=60;
		System.out.println("Fu num");
	}
	FuLei(int x)
	{
		System.out.println("Fu ...run"+x);
	}
}
class ZiLei extends FuLei
{
	ZiLei()
	{
		super(60);//隐式语句
		System.out.println("Zi run");
	}
	ZiLei(int x)
	{
		super(87878);//隐式语句
		System.out.println("Zi...run"+x);
	}
}
public class _03子父类中构造函数的特点 {
	
	public static void main(String[]args)
	{
		ZiLei z = new ZiLei();
		ZiLei z2 = new ZiLei(4444);
	}
}
class Teacher
{
	String name;
	Teacher(String name)
	{
		this.name=name;
	}
	void Show(){};
}
class student extends Teacher
{
	student(String name)
	{
		super(name);//直接调用父类的构造函数
	}
	void method()
	{
		super.Show();//直接调用父类的功能
	}
}

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

/*
 * 子父类中的构造函数。
 * 在对子类对象进行初始化时，父类对象的构造函数也会运行。
 * 那是因为子类的构造函数默认第一行有一条隐式的语句：super();
 * super();会访问父类空参数的构造函数。而且子类中所有的构造函数默认第一行都是super();
 * 
 * 为什么子类一定要访问父类中的构造函数。
 * 因为父类中的数据子类可以直接获取。所以子类对象在建立时，
 * 需要先查看父类是如何对这些数据进行初始化的
 * 所以子类在对象初始化时，要先访问一下父类中的构造函数。
 * 如果要访问父类中的构造函数，可以通过手动定义super语句的方式来指定。。。
 * 
 * 注意：super语句一定要定义在子类构造函数的第一行。
 *      如果第一行是this();那么默认的super();语句将被替代掉。他俩只能活一个
 *      
 * 结论：
 *      子类的所有构造函数，默认都会访问父类的空参构造函数。
 * 因为：子类的所有构造函数第一行，都存在一个隐式的super();语句。
 * 当父类中没有空参数的构造函数时，子类必须手动通过super形式来指定访问父类中的构造函数。 
 * 当然：子类的构造函数第一行，也可以手动指定this语句来访问本类中的构造函数。
 *       子类中至少会有一个构造函数来访问父类中的构造函数。
 * 
 */
class FuLei
{
	int num;
	FuLei()
	{
		int num=60;
		System.out.println("Fu num");
	}
	FuLei(int x)
	{
		System.out.println("Fu ...run"+x);
	}
}
class ZiLei extends FuLei
{
	ZiLei()
	{
		super(60);//隐式语句
		System.out.println("Zi run");
	}
	ZiLei(int x)
	{
		super(87878);//隐式语句
		System.out.println("Zi...run"+x);
	}
}
public class _03子父类中构造函数的特点 {
	
	public static void main(String[]args)
	{
		ZiLei z = new ZiLei();
		ZiLei z2 = new ZiLei(4444);
	}
}
class Teacher
{
	String name;
	Teacher(String name)
	{
		this.name=name;
	}
	void Show(){};
}
class student extends Teacher
{
	student(String name)
	{
		super(name);//直接调用父类的构造函数
	}
	void method()
	{
		super.Show();//直接调用父类的功能
	}
}

Final关键字

/*
 * Final：
 * 1，可以修饰类，函数，变量。
 * 2，被final修饰的类不可以被继承。（为了避免被继承，被子类复写）
 * 3，被final修饰的方法不能被复写。
 * 4，被final修饰的变量是一个常量（只能赋值一次），即可以修饰成员变量，又可以修饰局部变量
 *    当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字
 *    方便于阅读，而这个值不需要改变，所以加上final修饰。
 *    作为常量：常量的书写规范所有字母都大写，如果由多个单词组成，单词间通过"_”连接
 */
class FuTwo   //加上final 后，不能被ZiTwo继承
{
	final int x = 4;
	public static final double PI = 3.14;
	final void show1(){}//加上final后，此方法不能被子类复写
	void show2()
	{
		final int y = 9;//加上final后，此变量值将永久为“9”（不允许重新赋值了）
	}
}
class ZiTwo extends FuTwo
{
	void show()
	{
		System.out.println(super.PI);
	}
}

public class _04Final关键字 {
	
	public static void main(String[]args)
	{
		ZiTwo zt = new ZiTwo();
		zt.show();
		System.out.println("aa");
	}

}

抽象类

/*

 * 抽象类：abstract

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

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

 *

 * 抽象：看不懂

 * 特点：

 * 1，抽象方法一定要在抽象类中

 * 2，抽象类和抽象方法一定要被abstract修饰

 * 3，抽象类不可以new创建对象。因为调用抽象方法没意义。

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

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

 *    （白话说）就是被abstract修饰的父类中有几个方法，子类中必须覆盖几个方法

 *   

 * 抽象类和一般类没有太大的不同。

 * 该如何描述事物就如何描述事物。只不过该事物出现了一些看不懂的东西。

 * 这些不确定的不部也是该事物的功能，需要明确出来，但是无法定义主体。

 * 通过抽象方法来表示。

 *

 *-------------------------------------------------------------

 * 抽象类比一般方法多了个抽象函数，就是在类中可以定义抽象方法

 * 抽象类不可以实例化。

 *

 *特殊－－〉抽象类中可以不定义抽象方法，这样做仅仅是不让该类创建对象。

 */

abstract class Studente
{
	abstract void study();
	abstract void study1();
	void Sleep()
	{
		System.out.println("学生都有睡觉功能");
	}
}
class JiShuStudent extends Studente
{
	void study()
	{
		System.out.println("技术班");
		//抽象类的方法要被使用，必须由子类复写其所有的抽象方法后，建立子类对象调用。
	}
	void study1()
	{
		System.out.println("（白话说）就是被abstract修饰的父类中有几个方法，子类中必须覆盖几个方法");
	}
}
//class JiChuStudent extends Studente
//{
//	void study()
//	{
//		System.out.println("基础班");
//	}
//}
public class _05抽象类abstract {
	
	public static void main(String[]args)
	{
		//new Studetn();-->抽象类不可以new创建对象。因为调用抽象方法没意义。
		new JiShuStudent().study();
		//new JiChuStudent().study();
		new JiShuStudent().Sleep();//直接调用父类的“睡觉”方法
	}
}

---------------------- 黑马程序员 Android培训、期待与您交流！ ----------------------