黑马程序员 Java面向对象<二> 继承、多态、接口

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

  java中继承、多态、接口 在开发中经常用到下面简单总结一下用法

一、继承 

    好处:提高了代码的服用性,让类与类之间产生了关系,为另一个特征多态做前提

    父类的由来：其实是由多个类不断向上抽取共性内容而来的。

    java中对于继承，java只支持单继承。java虽然不直接支持多继承，但是保留了这种多继承机制，进行改良 

    单继承：一个类只能有一个父类

    多继承：一个类可以有多个父类

//定义一个动物类
class Animal{
	//动物具备的一些共性
	String color;
	int age;
	
	void show(){
		System.out.println("color = "+color+" age = "+age);
	}
	//动物都会吃
	void eat(String eat){
		System.out.println(eat);
	}
	//动物都会叫
	void call(String call){
		System.out.println(call);
	}
}
    
class Cat extends Animal{
	
	Cat(String color,int age){
		this.color = color;
		this.age = age;
	}
   
	//猫特有方法
	void catchMouse(){
		System.out.println("抓耗子");
	}
	
}
   
class Dog extends Animal{
	//狗特有方法
	Dog(String color,int age){
		this.color = color;
		this.age = age;
	}
	void look(){
		System.out.println("看门");
	}
}
public class Temp
{
	public static void main(String[] args){
        //通过构造方法初始化猫对象
		Cat c = new Cat("花花",2); 
        c.show();//调用父类方法
        c.eat("猫吃鱼");
        c.catchMouse();//调用子类特有方法
        
        Dog d = new Dog("旺财",1);
        d.show();
        d.eat("啃骨头");
	d.look();
	}

}

    子类所有构造函数的第一行,其实都有一条隐身的语句super()

    super().在调用父类中空参数的构造函数  

    问题：super()和this()是否可以同时出现的构造函数中。

    两个语句只能有一个定义在第一行，所以只能出现其中一个。

二、多态

  定义:某一类事物的多种存在形态

  

//定义一个动物类
class Animal{
	void eat(){
		System.out.println("动物吃东西");
	}
	//动物都会叫
	void call(){
		System.out.println("动物叫");
	}
}
    
class Cat extends Animal{
	 void call(){
		 System.out.println("咪咪叫");
	 }
	
	//猫特有方法
	void catchMouse(){
		System.out.println("抓耗子");
	}
	
}

public class Temp
{
	public static void main(String[] args){
        Animal a = new Cat();//向上转型
        a.eat();//调用父类中的方法
        a.call();//由于子类有所以调用自己有的
        //a.catchMouse();//编译失败父类没有这种方法
        
        //要调用需要向下转型
        Cat c = (Cat)a;
        c.catchMouse();
		
	}

}

  多态体现:

      父类或者接口引用指向或者接收自己的子类对象

   多态作用:

      多态的存在提高了程序的扩展性和后期可维护性

   多态前提:

      需要存在继承或者实现关系

      要有覆盖操作

   多态弊端:

       提高了扩展性,但是只能使用父类的引用访问父类中的成员 

   多态成员变量和成员函数  

    成员变量:编译和运行都参考等号的左边。

    成员函数(非静态):编译看左边，运行看右边。因为成员函数存在覆盖特性。

    静态成员函数:编译和运行都看左边。

  

   多态总结：其实我们生活中有很多地方也是用到多态的,比如生活的角色扮演,

        是儿子的话，看到爸爸应该叫爸爸。是学生看到老师，应该叫老师。

        我们在身份时时刻刻在进行不断的变化，这就是多态。

三、抽象类 abstract

   抽象定义：

         抽象就是从多个事物中将共性的,本质的内容抽取出来

    抽象类：

         java中可以定义没有方法体的方法,该方法的具体实现由子类完成,

         该方法称为抽象方法,包含抽象方法的类就是抽象类。     

    抽象类的特点：

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

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

    3、抽象类不可以被创建对象(实例化)。也就是不可以用new创建对象

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

    

//定义一个抽象动物类，里面有个抽象方法
abstract class Animal{
	public abstract void call();
	
}
 //定义一个猫类并继承动物类
class Cat extends Animal {
	//覆写动物类抽象方法
	public void call(){
		System.out.println("喵喵叫");
	}
}
//定义一个狗类并继承动物类
class Dog extends Animal{
	//覆写动物类抽象方法
	
	public void call(){
		System.out.println("汪汪叫");
	}
	
}
public class Temp
{
	public static void main(String[] args){
		Cat c = new Cat();
		//调用猫类方法
		c.call();
		//创建狗对象
		Dog d = new Dog();
		//调用狗类方法
		d.call();
	
	}

}

四、接口 interface

   接口可以简单的理解为主板上的各种插口,需要用时往上插。

   什么时候定义接口

    当一个抽象类的方法都是抽象的时候，这时可以将抽象类用 表示接口。

   接口中包含的成员,常见的有全局常量,抽象方法.

     注意接口中成员都有固定修饰符

    成员变量 public static final

    成员方法 public abstract

    interface Inter{

           public static final int X = 3;

           public abstract void show();

    }

   接口特点

    1、接口是对外提供的规则

    2、接口是功能的扩展 

    3、接口的出现降低了耦合性

    4、接口可以用来多实现

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

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

/*
笔记本电脑使用。
为了扩展笔记本的功能，但日后出现什么功能设备不知道。

定义一个规则，只要日后出现的设备都符合这个规则就可以了。
规则在java中就是接口。

*/
interface USB// 暴露的规则。
{
	public void open();
	public void close();
}


class BookPC
{
	public static void main(String[] args)
	{
		useUSB(new UPan());//功能扩展了。
		//useUSB(new UsbMouse());
	}

	//使用规则。
	public static void useUSB(USB u)//接口类型的引用，用于接收(指向)接口的子类对象。//USB u= new UPan();
	{
		if(u!=null)
		{
			u.open();
			u.close();
		}
	}
}
class UPan implements USB
{
	public void open()
	{
		System.out.println("upan open");
	}
	public void close()
	{
		System.out.println("upan close");
	}

}
class UsbMouse implements USB
{
	public void open()
	{
		System.out.println("UsbMouse open");
	}
	public void close()
	{
		System.out.println("UsbMouse close");
	}

}

   抽象类和接口的区别

   相同点：都是不断向上抽取而来的。

  1、抽象类只能被继承，而且只能单继承。

     接口需要被实现，而且可以多实现。 

  2、抽象类中可以定义非抽象方法，子类可以直接继承使用。

     接口中都有抽象方法，需要子类去实现。

  3、抽象类使用的是  is a 关系。

     接口使用的 like a 关系。 

  4、抽象类的成员修饰符可以自定义。

     接口中的成员修饰符是固定的。全都是public的。

五、final关键字

/* 
 * Final： 
 * 1，可以修饰类，函数，变量。 
 * 2，被final修饰的类不可以被继承。（为了避免被继承，被子类复写） 
 * 3，被final修饰的方法不能被复写。 
 * 4，被final修饰的变量是一个常量（只能赋值一次），即可以修饰成员变量，又可以修饰局部变量 
 *    当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字 
 *    方便于阅读，而这个值不需要改变，所以加上final修饰。 
 *    作为常量：常量的书写规范所有字母都大写，如果由多个单词组成，单词间通过"_”连接 
 */  
class Fu   //加上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 Zi extends Fu  
{  
    void show()  
    {  
        System.out.println(super.PI);  
    }  
}  
  
public class Temp {  
      
    public static void main(String[]args)  
    {  
        Zi zt = new Zi();  
        zt.show();  
       
    }  
  
}