JAVASE_面向对象下

• 多态

多态出现在父类和子类之间，接口和其实现之间。

package 多态的使用;
/**
 * 多态:简单的说就是一个对象对应着不同类型
 * 多态在代码中的实现：父类或者接口的引用指向其子类的对象
 * 多态的好处：提高了代码的扩展性，前期定义的代码可以使用后期的代码内容
 * 多态的弊端：前期定义的代码不能调用后期对象特有的方法或属性
 * 多态的前提：
 * 		1.必须有关系：继承或者实现
 * 		2.要存在覆盖
 * @author Administrator
 *
 ***注意：在多态中（父类引用子类对象）
 *多态成员函数的特点（非静态：非静态才有重写的特性）：
 *在编译时期：参阅引用型变量的类中是否含有调用的方法（父类），如果有编译成功，如果没有编译失败
 *在运行时期：参阅所属的类中是否有调用的方法（看子类）
 *总结：编译看父类。运行看子类。
 *
 *在多态中成员变量中的特点：
 *无论编译还是运行都参考引用型变量（父类）的变量值。
 *
 *在多态中静态成员函数的特点：
 *无论编译和运行都参考的是父类。（因为静态成员函数压根就不存在重写（覆盖），只存在重载）
 */
public class 多态 {
	
		public static void main(String [] args){
			动物 cat = new 猫();//自动类型提升，猫对象提升到了动物类型，但是特有功能无法访问
												//动物 cat ：在创建对象时，创建的是猫类绑定在动物类上，
												//作用是：限制对特有功能的访问
												//专业讲：向上转型。将子类型隐藏就不用使用子类特有的方法了
			cat.eat();//只能访问其父类拥有的属性和方法，向上转型使得猫类对自己特有的方法被父类隐藏
			
			猫 cat1 = new 猫();//若要向下转型的话，必须使用子类的引用
			cat1.eat();
			cat1.say();
		}
}
abstract class 动物{
	abstract void eat();
}
class 猫 extends 动物{
	void eat() {
		System.out.println("吃鱼");
	}
	void say(){
		System.out.println("喵");
	}
}
class 狗 extends 动物{
	void eat() {
		System.out.println("啃骨头");
	}
	void say(){
		System.out.println("汪汪");
	}
}

<pre name="code" class="java">多态的使用:(接口实现扩展性)
package 多态的使用;
/**
 * 模拟计算机主板的使用:
 * @author Administrator
 *
 */
public class 主板_多态的使用 {
	
		public static void main(String[] args){
			MainBoard mb = new MainBoard();
			mb.userPCI(new SoundCard());
		}
}
//主板
class MainBoard{
	public void run(){
		System.out.println("MainBoard run");
	}
	public void userPCI(PCI p){
		if( p != null ){
			p.open();
			p.use();
			p.close();
		}
	}
}
//PCI接口
interface PCI{
	public void open();
	public void use();
	public void close();
}


class NetCard implements  PCI{
	public void open() {
		System.out.println("正在打开网卡");
	}
	public void use() {
		System.out.println("正在使用网卡");
	}
	public void close() {
		System.out.println("网卡正在关闭");
	}
}


class SoundCard implements  PCI{


	@Override
	public void open() {
		System.out.println("正在打开声卡");
	}


	@Override
	public void use() {
		System.out.println("正在使用声卡");
	}


	@Override
	public void close() {
		System.out.println("正在关闭声卡");
	}


}

结果:
正在打开声卡
正在使用声卡
正在关闭声卡

<pre name="code" class="java">抽象类实现多态：
package 多态的使用;
public class 开车_多态的应用 {
	public static void main(String[] args) {
		Person p = new Person("aa");
		p.intr(new JP());
	}
}

class Person{
	String name;
	public Person(String name){
		this.name = name;
	}
	public void intr(Cars car){
		System.out.println("大家好，我叫"+this.name+"我驾驶的是"+car.intr());
	}
}
abstract class Cars{
	public abstract String intr();
}
class JP extends Cars{
	@Override
	public String intr() {
		// TODO Auto-generated method stub
		return "吉普车";
	}
}
class BYD extends Cars{
	@Override
	public String intr() {
		// TODO Auto-generated method stub
		return "比亚迪车";
	}
	
}

• Object类

1. object类是所有类的超类，也就是所有类的父类，上帝类。

• 内部类

1. 将一个类定义在另一个类的里面，

<pre name="code" class="java">package 内部类的使用;


public class 内部类 {


		public static void main(String[] args){
			Outer out = new Outer();
			out.method();
			//直接访问内部类
			Outer.Inner inner= new Outer() . new Inner();
			//匿名内部类
			out.method3();
		}
}


//抽象类
abstract class absDemo{
	int x = 100;
	abstract void show();
}




//外部类（组合类）
/**
 * 内部类可以直接访问外部类中的成员，外部类要访问内部类，必须创建内部类对象
 * @author Administrator
 *
 *内部类使用场景：当一个事物的内部还存在事物的时候，可以考虑采用内部类来描述。
 *					因为内部事物在使用外部事物的内容，包含外部类的类变量和函数。
 *
 */
class Outer{
	private int x = 5;
	
	//内部类
	class Inner{
		private int x = 6;
		public void method(){
			 int x = 7;
			System.out.println("内部类Method中x:"+x);
			System.out.println("内部类inner类中x："+this.x);//this指代本类对象
			System.out.println("外部类Outer类中的x:"+Outer.this.x);//标注这个this是外部类的this
		}
	}
	
	public void method(){
		
		//外部类访问内部类
		Inner in = new Inner();
		in.method();
		
		System.out.println("外部类x:"+x);
	}
	public void method2(){
		//内部类定义在局部位置
		 class Inner1{
			void method(){
				System.out.println(Outer.this.x);
			}
		}
			new Inner1().method();
	}
	
	/**
	 * 匿名内部类：必须继承或实现某个接口才能使用匿名内部类
	 * 匿名内部类格式: new 父类或接口(){};//创建了一个匿名内部类对象 
	 */
	public void method3(){
		new absDemo(){
			public void show(){
				System.out.println("匿名内部类x:"+x);
			}
		}.show();
	}
}
结果：
内部类Method中x:7
内部类inner类中x：6
外部类Outer类中的x:5
外部类x:5
匿名内部类x:100