黑马程序员——面向对象（二）

------- android培训、java培训、期待与您交流！ ----------

继承

继承是指一个对象直接使用另一对象的属性和方法。

示例：一个Student类，一个Worker类，并把他们的共性都提取出来形成一个Person类。

Person类

//该类提取除了人的属性name和age
public class Person {
	String name = "张三";
	int age;
	public void eat() {
		System.out.println("eat");
	}
}

Student类

//Student通过extends关键字继承Person类，便继承了Person类的属性和方法
public class Student extends Person {
	//学生类的学习方法
	public void study() {
		System.out.println("学习");
	}
	
	public static void main(String[] x){
		Student student = new Student();
		student.eat();
		student.study();
		System.out.println(student.age);
	}
}

Worker类

//Worker通过extends关键字继承Person类，便继承了Person类的属性和方法
public class Worker extends Person {
	//Worek类自有的方法
	public void  work() {
		System.out.println("工作");
	}
	
	public static void main(String[] x){
		Worker worker = new Worker();
		//调用自身的方法
		worker.work();
		//调用从父类继承的方法
		worker.eat();
		System.out.println(worker.name);
	}
}

上述Student和Worker通过extends关键字继承Person类，便拥有了Person类的属性和方法。

Person类就是Student类和Worker类的父类；Student类和Worker类就是Person类的子类；

继承关系中的super和this

在继承关系中如果子类子类与父类中出现了同名的属性，且属性法都不是私有的时候；

那么直接调用这个同名的属性子类中的属性会优于父类中属性；

这是为了区分子类和父类的属性就的使用super关键字和this关键字。

this代表子类的属性，super代表父类的属性。

例如：

	public class Person {
		String name = "张三";

		public void eat() {
			System.out.println("eat");
		}
	}
	public class Stu extends Person {
		String name = "李四";
		public void Person() {
			System.out.println(name); //默认打印子类的name属性值“李四”
			System.out.println(this.name); //打印子类的name属性值“李四”
			System.out.println(super.name); //打印父类的name属性值“张三”
		}
	}

this代表子类对象的引用，super代表父类对象的引用。

覆盖（重写）

当子类继承父类，子类中的方法和父类中德方法一致时，这时子类的方法会优于父类的方法，系统会直接调用子类的方法；这种情况就叫覆盖，也叫重写。

public class Phone{
		public void show() {
			System.out.println("来电显示号码");
		}
	}
	public class Iphone extends Phone {
		//覆盖父类中的show方法
		public void show() {
			super.show();  //继承父类中show方法的功能
			System.out.println("来电显示姓名");  //子类方法中新增的方法
		}
	}

上述子类不仅具有自己show方法的功能，还继承了父类show方法的功能。

注意：1、子类覆盖父类，必须保证子类的权限大于和等于父类的权限，才可能覆盖，否则覆盖失败。

            2、静态方法只能覆盖静态方法。
从载：函数的参数列表不一样。

从写：子父类方法一摸一样。

子类的所有的构造函数，默认都会访问父类中德构造函数，因为子类每一个构造函数内的第一行都有一个隐式的super()；

当父类中没有空参数的构造函数时，子类必须手动通过super或者this语句形式来指定要访问的构造函数。

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

final关键字

final:最终的，作为一个修饰符；可以修改类、函数、属性。

被final修饰的类不可以被继承。

被final修饰的函数不能被复写。

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

描述事物时，一些数据的出现时固定的，那么这时为了增强阅读性，都给这些值取个名字。方便于 阅读，而这个值不需要改变，所以加上final修饰；作为常量。

抽象类

当多个类中出现相同功能，但是功能主题不同，这时我们可以抽取功能定义来形成抽象类，而不抽取功能主体。

        //定义一个抽象类
	public abstract class Student{
		abstract void study();
	}
	//定义一个继承抽象类的子类
	public class BaseStudent extends Student {
		//复写父类的抽象方法
		void study() {
		System.out.println("base study");
		}
	}

抽象类的特点：

1、抽象方法一点光在抽象类中；

2、抽象方法和抽象类都必须被absstract关键字修饰；

3、抽象类不可以创建对象，因为调用抽象方法没有意义；

4、抽象类中的抽象方法要被使用，必须由子类复写其所有的抽象方法后，建立子类对象。如果子类对象只覆盖

了部分抽象方法；那么该子类还是一个抽象类。

抽象类和一般类没有太大不同；该如何描述事物就如何描述事物，只不过该事物出现了一些抽象的方法。

这些抽象的部分，也是该事物的功能，需要明确出现，但无法定义主体；通过抽象方法来实现。

抽象类比一般类多了抽象方法（就是在类中定义抽象方法）。

切记抽象类不可以被实例化。

抽象类中可以不定义抽象方法，这样做只是为了不让该类建立对象。

抽象类具体应用示例：

//定义一个抽象员工类 包含员工的基本信息
	public abstract class Employee {
		private String name; 
		private double sal;
		//基本员工类构造函数
		public Employee(String name, double sal) {
			this.name = name;
			this.sal = sal;
		}
		//定义一个抽象的work方法
		public abstract void work();
	}

	//普通员工类继承基本员工类
	public class BaseEmp extends Employee {
		//普通员工类的构造方法，直接调用父类的属性值
		public BaseEmp(String name, double sal) {
			super(name, sal);
		}
		//重写work方法
		public void work() {
			System.out.println("baseEmployee work");
		}
	}
 
	//经理类继承基本员工类
	public class Manager extends Employee {
		//子类自己的属性
		private int bonus;
		//子类的构造方法，父类有的属性直接调用腹泻的
		public Manager(String name, double sal, int bonus) {
			super(name, sal);
			this.bonus = bonus;
		}
		//重写work方法
		public void work() {
			System.out.println("manager work");
		}
	}

接口 

interface用于定义接口；

接口定义时：

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

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

   常量：public  static  final

   方法：public  abstract

接口中的成员都是public的。

接口是不能创建对象的，因为有抽象方法。需要被子类实现，子类对接口中德抽象方法全部覆盖，子类才可能实例化，

否则子类是个抽象类。

//定义一个借口
	interface A{
		public static final int NUM=0;  //接口的属性会被public static final修饰
		public abstract void show();   //定义一个抽象方法会被public abstract修饰
	}
	//定义一个类实现A接口
	public class B implements A{
		//复写A接口的show方法
		public void show() {
		}
		
	}

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

接口可以多继承。

接口与接口之间是继承关系，而且，接口与接口直接可以多继承。

interface A{
		public abstract void show();
	}
	interface B{
		public abstract void show1();
	}
	public class C{
		
	}
	//定义一个类实现A接口和B接口并继承C类
	public class D extends C implements A,B{
		//复写A接口的show方法
		public void show() {
		}
		//复写B接口的show1方法
		public void show1() {
		}
		
	}

接口的特点：

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

2、接口是功能的特点。

3、几口可以用俩实现。

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

5、接口与接口之间可以有几场关系。

总之：基本功能定义在类中，扩展功能定义在接口中！

------- android培训、java培训、期待与您交流！ ----------