黑马程序员---------继承、抽象、接口、多态、内部类

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、继承：

子类继承父类中的非私有的属性和方法。

java只支持单继承（如果继承两个有同样方法的父类，那么就不知道继承到那个父类的，所以java只支持单继承）。但是我们可以用多接口来实现。

1、作用：

           1) 提高代码的复用性；

              2）类与类之间产生关系、与类的另外一特征产生前提。

注意：1）父类中的私有部分，子类对象无法直接访问。

            2）当父类中没有空构造函数时，子类需要显示定义一个super访问的构造函数。

            3）super语句必须定义在构造函数的第一行，故不能与this语句同时存在

 2、super关键字： 代表的是父类的那片空间，用法必须是  super.(属性、方法)

 3、重写：当一个子类继承一父类，而子类中的方法与父类中的方法的名称，参数个数、类型都完全一致

        注意：1）子类方法中重写、必须要保证权限大于等于父类权限。                  

                        2）父类中的私有方法不能被重写；

                        3）父类中的静态方法只能被静态方法覆盖；

代码：

class  Fu{
 int num = 4;
  public Fu()
  {  
  }
  public static void show()
  {
 System.out.println("Fu方法运行。。。。");  
  }
}
class Zi extends Fu
{
 int num = 5;
 public Zi()
 {
  this(3);
 }
 public Zi( int x)
 {
  System.out.println("  构造函数");
 }
 public static void show()
   {
  System.out.println("Zi方法运行。。。。");  
   }  
}

二、抽象（abstract）

1.定义：描述一件事物，没有足够的信息。

         抽象的事物虽然不具体，但是可以简化。

  2.特点：a)抽象方法一定在抽象类中。都需要用abstract来进行修饰。

b)抽象类不能被实例化。

c)子类只有重写了所有的抽象方法，子类才能实例化。不然子类还是抽象类。

注意：1)抽象类中具有抽象方法。

                2）抽象类一定是一个父类。

                3）抽象类中可以不定义抽象方法，只是不让类实例化。

                4）abstract与 final、static、private不能同时存在。

原因：

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

                private:抽象类中的私有的抽象方法，不被子类所知，就无法被复写。

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

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

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

代码：

public abstract class Fruit { 
public void price() { 
System.out.println("水果价格"); 
} 
public abstract void weight(); 
} 

三、接口

1、    作用：用于描述事物的额外功能。 可以让子类有更多的方法。

2、特点：1）.不能被实例化。

         2).所有的方法都是抽象方法，只有子类实现了所有的抽象方法。才能被实例化。

        3)接口可以用来多实现。这也是对多继承不支持的转换形式。java支持多实现。

4）接口中所有的属性都是常量。所有的方法都是抽象方法，public abstract

  5) 接口是对外暴露的规则。

        6) 接口是程序的功能扩展。

        7) 接口的出现降低耦合性。 

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

        9) 接口与接口之间可以有继承关系。而且可以多继承。

3、接口和抽象类的区别?

    1.类与类是继承关系 。is  a.

        类与接口是实现关系。 like.

    2.抽象类中可以定义抽象和非抽象方法。

        接口中所有的方法都是抽象方法。

package cn.it;
//接口a
interface InterA{
	public abstract void show();	
}
interface InterB{
	public abstract void show();
}
//实现接口A 、B
class Inter implements InterA,InterB{

	public void show() {
		System.out.println(" show");
	}
}


public class InterDemo {

	public static void main(String[] args) {
			InterA inter = new Inter();
			inter.show();//调用接口A中的方法。
	}
}

四、多态

一个父类有多个不同特色的子类。
1.体现：父类的引用或接口的引用指向子类对象。
向下转型的好处：隐藏了子类型，提高了代码的扩展性.
弊端：只能使用父类的功能，不能使用子类的功能。
向上转型：好处：可以使用子类的特有功能，但是先要通过instanceof判断。
坏处：面对具体的子类型，向下转型具有一定的风险。

对象的多种形态，在编译一种，在执行时一种。成员函数在调用时，编 译看左边，运行看右边。

interface Animal{
	void eat();
	void lookjia();
}
class Dog implements Animal{

	public void eat() {
		System.out.println("骨头");
	}

	public void lookjia() {
		System.out.println("狗看家");
	}
	
}

class Cat implements Animal {
	public void eat(){
		System.out.println("鱼");
	}

	public void lookjia() {
		System.out.println("看老鼠");
	}
}

class Zhu implements Animal {

	public void eat() {
		System.out.println("杂粮");
	}

	public void lookjia() {
		System.out.println("猪看？？？");
	}
	
}

public class Duotai {

	public static void main(String[] args) {
		/*
		 * 未使用接口时。调用
			Dog dog = new Dog();
			Cat cat = new Cat();
			Zhu zhu = new Zhu();
			Duotai d  =new Duotai();
			d.Methrod(dog);
			d.Methrod(cat);
			d.Methrod(zhu);
			*/
		Animal dog = new Dog();
		Animal cat = new Cat();
		Animal zhu = new Zhu();
//		Duotai Duotai  =new Duotai();
		Duotai.Methrod(dog);
		Duotai.Methrod(cat);
		Duotai.Methrod(zhu);
		
	}
	
	public static void Methrod(Animal anmal) {
		anmal.eat();
		anmal.lookjia();
	}
	/*
	public static void Methrod(Dog dog) {
		dog.eat();
		dog.lookjia();
	}
	
	public static void Methrod(Cat cat) {
		cat.eat();
		cat.lookjia();
	}
	
	public static void Methrod(Zhu zhu) {
		zhu.eat();
		zhu.lookjia();
	}
    */
} 

五、内部类

1.什么是内部内？

类定义在另一个类的里面，对里面那个类就称为内部类。

 编译时，如果代码中有内部类，生成的class文件中会含有这样的文件：Outter$Inter.class。

注意：a)  内部类可以直接访问外部类中的成员，包括私有。

   b) 外部类要访问内部类，必须建立内部类对象。

   c) 当内部类中定义了静态成员时，该内部类必须是static的。

           d）当外部类中的静态方法访问内部类时，内部类也必须是static的。

           e）在实际应用中，内部类通常被定义为private，而很少定义为public。

当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。可以直接建立内部类对象。

        格式：

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

        如：    Outer.Inner in =new Outer().new Inner();

当内部类在外部类中的成员位置上时，可以被成员修饰符所修饰。比如：

        private：将内部类在外部类中进行封装。 

        static：内部类就局部static的特性。但是当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。

在外部其他类中，直接访问static内部类的非静态成员的格式为：

        new 外部类名.内部类名（）.方法名（）；

        如：new  Outer.Inner().function();  静态内部类相当于一个外部类，随类的加载而加载。

在外部其他类中，直接访问static内部类的静态成员格式为：

        外部类名.内部类名.方法名（）；

        如：Outer.Inner.function();

注意：final编译的时候就会给所有的成员变量赋值。 /

匿名内部类：这个类只是用一次，可以简化书写。前提;内部类需要继承或实现外部的类或接口。

代码：

new WindowAdapter() { 
public void windowClosing(WindowEvent e) { 
dispose(); 
System.exit(0); 
} 
}