面向对象下总结

1、抽象类总结：

package com.laobi.day09;

public class AbstratorDemo {
	/**
	 * 抽象类：
	 * 抽象：笼统，模糊，看不懂！不具体
	 * 
	 * 特点：
	 * 1、方法只有声明没有实现时，该方法就是抽象方法，需要被abstract修饰
	 *    抽象方法必须定义在抽象类中，该类必须也被abstract修饰
	 * 2、抽象类不可以实例化。为什么？因为调用抽象方法没意义
	 * 3、抽象类必须有其子类覆盖了所以方法后，该子类才可以实例化，
	 *   否则这个子类还是抽象类
	 *   
	 *1、抽象类中有构造函数吗？
	 *有，用于给子类对象进行初始化
	 *2、抽象类可以不定义抽象方法吗？
	 *可以的，但是很少见，目的就是不让该类创建对象。AWT的适配器对象就是这种类
	 *3、抽象关键字不可以和哪些关键字共存？
	 *private 不行
	 *static  不行
	 *final   不行
	 *4、抽象类和一般类的区别？
	 *相同点：
	 *   抽象类和一般类都是用来描述事物的，都在内部定类成员
	 *不同店：
	 *   1、一般类有足够的信息描述事物
	 *      抽象类描述事物的信息有可能不足
	 *   2、一般类中不能定义抽象方法，只能定义非抽象方法
	 *      抽象类中可以定义抽象方法，同时也能定义非抽闲方法
	 *   3、一般类可以被实例化
	 *      抽象类不可以被实例化
	 *5、抽象类一定是个父类吗？
	 *是的，因为需要子类覆盖其方法后才可以对子类实例化 
	 */

}
class DemoA extends Demo
{
	void show()
	{
		System.out.println("DemoA show");
	}
}
class DemoB extends Demo
{
	void show()
	{
		System.out.println("DemoB show");
	}
}
abstract class Demo
{
	abstract void show();
}

2、final关键字讲解：

package com.laobi.day09;

public class Final {
	/**
	 * final关键字
	 * 1、final是一个修饰符，可以修饰类，方法，变量
	 * 2、final修饰的类不可以被继承
	 * 3、final修饰的方法不可以被覆盖
	 * 4、final修饰的变量是一个常量，只能赋值一次  
	 * 为什么要用final修饰变量？
	 * 其实在程序中，如果一个数据是固定的，那么直接使用这个数据就可以了，
	 * 但是这样阅读行性差，所以给该数据起个名称。
	 * 而且这个变量名称的值不能变化，所以加上final固定
	 */
	public static void main(String[] args) {
		new Zi();
	}

}
 class Fu
{
	void method()
	{
//		System.out.println("gogogo");
	}
}
class Zi extends Fu
{
	void method()
	{
		System.out.println("Running");
	}
}

3、接口部分：

package com.laobi.day09;

public class InterfaceDemo {
	/*
	 * 接口
	 * 接口中的成员都是公共的权限
	 * 
	 * 类与类之间是继承关系，类与接口之间是实现关系
	 * 
	 * 接口不可以实例化
	 * 只能由实现了接口的子类并覆盖了接口中所有的抽象方法后
	 * 该子类才可以实例化，否则，这个子类就是一个抽象类
	 * 
	 * 在java中不直接支持多继承，因为会出现调用的不确定性，
	 * 所以java将多继承机制进行改良，在java中变成了多实现
	 * 
	 * 一个类可以实现多个接口
	 * 
	 * 接口的特点：
	 * 1、接口是对外暴露的规则
	 * 2、接口是程序扩展的功能
	 * 3、接口的出现降低耦合性
	 * 4、接口可以用来多实现
	 */
	public static void main(String[] args) {
		Te t = new Te();
		t.show();
		
	}

}
interface A
{
	public void show();
}
interface B
{
	public void show();
}
class Te implements A,B
{
	public void show()
	{
		System.out.println("fuck");
	}
}

//接口到出现避免了单继承到局限性
interface CC
{
	void show();
}
interface MM
{
	void method();
}
interface QQ extends CC,MM
{
	//接口与接口之间是继承关系，而且支持多继承
	void function();
}
class WW implements QQ
{
	public void show(){}
	public void method(){}
	public void function(){}
}

4、接口与抽象类的区别：

相同点：

 都是不断向上抽取而来的

 

 不同点：

 1、抽象类需要被继承，而且只能是单继承

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

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

    接口中只能定义抽象方法，必须由子类去实现

 3、抽象类的继承，是is a关系，在定义该体系的基本共性内容

    接口的实现是like a关系，在定义体系额外功能

5、多态总结：

package com.laobi.day10;

public class DuoTai {
	/**
	 * 多态：某一事物的多种形态，简单说，就是一个对象对应着不同类型
	 * 
	 * 多态在代码中的体现：
	 *    父类或者接口的引用指向其子类的对象
	 *
	 * 多态的好处：
	 * 提高了代码的扩展性，前期定义的代码可以使用后期的内容 
	 * 
	 * 多态的弊端：
	 * 前期定义的内容不能使用（调用）后期子类的特有内容
	 * 
	 * 多态的前提：
	 * 1、必须有关系，继承，实现。
	 * 2、要有覆盖
	 * 
	 */
	public static void main(String[] args) {
		method(new Cat());
		Animal a = new Cat();
		a.eat();
		Cat c = (Cat) a;//向下转型的目的是为了使用子类中的特有方法
		//注意：对于转型，自始至终都是子类在做着类型的变换
		c.eat();
	}
	public static void method(Animal a)
	{
		a.eat();
		if(a instanceof Cat)
		{
			//instanceof：用于判断对象的具体类型，只能用于引用数据类型判断
			Cat c = (Cat) a;
			c.catchMouse();
		}
	}

}
abstract class Animal
{
	abstract void eat();
}

class Dog extends Animal
{
	void eat()
	{
		System.out.println("啃骨头");
	}
	
}
class Cat extends Animal
{
	void eat()
	{
		System.out.println("吃鱼");
	}
	void catchMouse()
	{
		System.out.println("抓老鼠");
	}
}

6、多态的特点：

package com.laobi.day10;

public class DuoTai3 {
	/**
	 * 多态的特点：
	 * 成员函数：
	 *    编译时，要查看引用变量所属的类中是否有所调用的成员
	 *    在运行时，要查看对象所属的类中是否有所调用的成员
	 *    简单说，编译看左边，运行看右边
	 * 成员变量：
	 *    只看引用变量所属的类
	 *    简单说，编译和运行都看等号左边
	 * 静态函数：
	 *    编译时：参考引用型变量所属的类中是否有调用的静态方法
	 *    运行时：参考引用型变量所属的类中是否有调用的静态方法
	 *    简单说，编译和运行都看左边
	 *    
	 *    其实对于静态方法，是不需要对象的，直接调用类名即可
	 */
	public static void main(String[] args) {
		Zi z = new Zi();
		System.out.println(z.num);
		Fu f = new Zi();
		f.show();
		f.method();
		System.out.println(f.num);
	}

}
class Fu
{
	int num = 3;
	void show()
	{
		System.out.println("fu show");
	}
	static void method()
	{
		System.out.println("fu static");
	}
}
class Zi extends Fu
{
	int num = 4;
	void show()
	{
		System.out.println("zi show");
	}
	static void method()
	{
		System.out.println("zi static");
	}
}

7、内部类：

package com.laobi.day10;

public class NeiBuLei {
	/**
	 * 内部类：将一个类定义在另一个类的里面，对里面那个类就称为内部类
	 * 
	 * 访问特点：
	 * 1、内部类可以直接访问外部类的成员，包括偶私有成员
	 * 2、而外部类要访问内部类中的成员必须要建立内部类的对象
	 * @param args
	 */
	public static void main(String[] args) {
		
	}

} 
class Outer
{
	private int num = 3;
	class inner
	{
		void show()
		{
			System.out.println("show run..."+num);
		}
	}
}