黑马程序员——Java基础--面向对象（2）

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

一  多态

    多态概述：某一个事物，在不同时刻表现出来的不同状态。

    多态前提和体现：

    有继承关系 ；

    有方法重写 ；

    有父类引用指向子类对象。

    多态的好处：提高了程序的维护性(由继承保证)；提高了程序的扩展性(由多态保证)。

    多态的弊端：不能访问子类特有功能。

class AnimalTest {
	public static void main(String[] args) {
		// 父类引用指向子类对象
		Animal a = new Cat();
		// 输出父类成员变量
		System.out.println(a.num);
		// 调用父类成员方法
		a.eat();
		a.sleep();
	}
}
class Animal {
	int num = 10;
	public void eat() {
		System.out.println("动物吃东西");
	}
	public static void sleep() {
		System.out.println("动物晚上睡觉");
	}
}
class Cat extends Animal {
	int num = 20;
	public void eat() {
		System.out.println("猫吃鱼");
	}
	public static void sleep() {
		System.out.println("猫白天睡觉");
	}
}

二  抽象类

    抽象类的特点： 

    1：抽象方法只能定义在抽象类中，抽象类和抽象方法必须由abstract关键字修饰（可以描述类和方法，不可以描述变量）。 

    2：抽象方法只定义方法声明，并不定义方法实现。

    3：抽象类不可以被创建对象(实例化)。 

    4：只有通过子类继承抽象类并覆盖了抽象类中的所有抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。 

    5: 抽象类只能单继承。

    关键字abstract 不能和以下关键字共存：

    private    冲突 -- 对子类隐藏,而 abstract 必须让子类重写

    final      冲突 -- 不能被重写,矛盾

    static     无意义-- 类名调用,没有方法体,无意义

class TeacherDemo {
	public static void main(String[] args) {
		BaseTeacher baseTeacher = new BaseTeacher("小李", 25);
		baseTeacher.teach();
		System.out
				.println(baseTeacher.getName() + "---" + baseTeacher.getAge());
	}
}
abstract class Teacher {
	private String name;
	private int age;
	Teacher() {}
	Teacher(String name, int age) {
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	// 讲课
	public abstract void teach();
}
class BaseTeacher extends Teacher {
	BaseTeacher() {
		// super();
	}
	BaseTeacher(String name, int age) {
		super(name, age);
	}
	public void teach() {
		System.out.println("学好基础！");
	}
}

三  接口

    接口：为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现。

    接口的特点：

    接口用关键字interface表示。格式：interface接口名 {}

    类实现接口用implements表示。格式：class类名 implements 接口名 {}

    接口不能实例化。

    但是按照多态的方式，由具体的子类实例化。

    接口的子类要么是抽象类，要么重写接口中的所有抽象方法。

    接口中的成员变量只能是常量。成员方法只能是抽象方法。

    类与接口是实现关系，可以单实现，也可以多实现。还可以在继承一个类的同时实现多个接口。

    接口与接口是继承关系，可以单继承，也可以多继承。

class Demo{
	public static void main(String[] args){
		MaXiMao  mxm = new MaXiMao("加菲" , 2);
		mxm.eat();
		mxm.sleep();
		mxm.shushu();
		mxm.dance();
		System.out.println();
	}
}
abstract class Animal {
	String name ;
	int leg;
	Animal (String name ,int leg){
		this.name = name;
		this.leg = leg;
	}
	public void sleep(){
		System.out.println("黑天睡觉");
	}
	public abstract void eat();
}
//定义猫 
class  Cat extends Animal{
		Cat(String name,int leg){
			super(name,leg);
		}
		public  void eat(){
			System.out.println("吃鱼,吐刺儿!!!!!");
		}
}
//定义训练接口
interface Train{
	public abstract void dance();
	public abstract void shushu();
}
//马戏猫 
	//MaXiMao不是抽象的, 并且未覆盖Train中的抽象方法shushu()
class MaXiMao extends Cat implements Train { 
		MaXiMao(String name,int leg){
			super(name,leg);
		}
		public  void shushu(){
			System.out.println("数数 123");
		}
		public  void dance(){
			System.out.println("跳舞");
		}
}

四  内部类

    把类定义在其他类的内部，这个类就被称为内部类。

    内部类的访问特点：内部类可以直接访问外部类的成员，包括私有。外部类要访问内部类的成员，必须创建对象。

    成员内部类：

    成员内部类在外界创建对象：

    外部类名.内部类名 对象名 = 外部类对象.内部类对象；

    成员内部的常见修饰符：private 为了保证数据的安全性；static 为了让数据访问更方便。

    局部内部类：

    可以直接访问外部类的成员；

    可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能；

    匿名内部类：

    前提：存在一个类或者接口。本质是一个继承了类或者实现了接口的子类匿名对象。

class OuterTest {
	public static void main(String[] args) {
		// 创建外部了对象
		Outer o = new Outer();
		o.show();
	}
}
class Outer {
	int num = 3;
	public static void show() {
		final int num = 6; // 从内部类中访问本地变量num;需要被声明为最终类型
		// 局部内部类
		class Inner {
			public void fun() {
				System.out.println("num:" + num);
			}
		}
		// 创建内部类对象
		Inner i = new Inner();
		i.fun();
	}
}