java面向对象——多态、设计模式、代码块

面向对象——多态

一、定义：一个对象可以有多种形态。

二、前提：

• 需要存在继承或者实现关系（多态是对象的概念,和类没有关系）；
• 要有覆盖操作。

三、多态的特点:

•  把子类对象赋给父类变量，在运行时期会表现出具体的子类特征（父类或者接口的引用指向或者接收自己的子类对象）；
• 成员变量：只看引用变量所属的类；
• 成员函数：编译时，要查看引用变量所属的类中是否有调用的成员。运行时，要查看对象所属的类中是否有所调用的成员

四、作用：

• 多态的存在提高了程序的扩展性和后期可维护性（屏蔽不同子类对象之间的实现差异）；
• 降低耦合度；

五、引用类型转换：

SuperDemo sd  = new SubDemo();//向上转型以后，如果父子都有相同函数，访问函数子类的函数

		sd.test1();
		//注意：当向上转型以后，只能访问父类和子类共有的方法
		SubDemo sd1 = (SubDemo)sd;//向下转型
		sd1.test2();

		//向下转型必须先向上转型
		Fruit f = new Apple();
		Orange o = (Orange) f;//不行

注意：判断某一个对象是否是某一种类型:instanceof运算符:

boolean result = 对象 instanceof 类名/类型

设计模式

一、单例设计模式：

class  JavaDemo
{
	public static void main(String[] args) 
	{
		//单例：单个实例
		//System.out.println("Hello World!");
		//new SingleDemo();
		/*
		SingleDemo sd1 = SingleDemo.getSD();
		System.out.println(sd1);

		SingleDemo sd2 = SingleDemo.getSD();
		System.out.println(sd2);
		*/

		SingleDemo1 sd3 = SingleDemo1.getSD();
		System.out.println(sd3);
		SingleDemo1 sd4 = SingleDemo1.getSD();
		System.out.println(sd4);

	}
}

class SingleDemo
{
	//饿汉式
	private static SingleDemo sd = new SingleDemo();
	private SingleDemo(){

	}
	public static SingleDemo getSD(){
		return sd;
	}
}

class SingleDemo1
{
	//懒汉式
	private static SingleDemo1 sd;
	private SingleDemo1(){

	}


	public static SingleDemo1 getSD(){

		if(sd==null){
			sd = new SingleDemo1();
			return sd;
		}else{
			return sd;
		}
		
		
	}
}

二、工厂设计模式：

class  FactoryDemo
{
	public static void main(String[] args) 
	{
		Fruit f = null;
		f = Factory.get("橘子");
		f.eat();
	}
}

interface Fruit
{
	public void eat();
}

class Apple implements Fruit
{
	public void eat()
	{
		System.out.println("吃苹果");
	}
}

class Orange implements Fruit
{
	public void eat()
	{
		System.out.println("吃橘子");
	}
}

class Factory//工厂类
{
	public static Fruit get(String name)
	{
		Fruit f = null;
		if("苹果".equals(name))//这里不能把name写在前面，否者会出现空指针异常
		{
			f = new Apple();
		}
		if("橘子".equals(name))
		{
			f = new Orange();
		}
		return f;
	}
}

三、代理模式（保护核心业务）：

class  ProxyDemo
{
	public static void main(String[] args) 
	{
		ProxyCl p = new ProxyCl(new Real());
		p.browse();
	}
}

interface Net
{
	public void browse();
}

class Real implements Net//真真实现功能的类
{
	public void browse()
	{
		System.out.println("上网了");
	}
}

class ProxyCl implements Net//代理类，代理类可以实现更多的辅助功能
{
	private Net net;
	public ProxyCl(Net net)
	{
		this.net = net;
	}
	
	public boolean check()
	{
		boolean inf = true;
		return inf;
	}

	public void browse()
	{
		this.check();
		this.net.browse();
	}
}

四、适配器模式：

在继承接口时，就必须全部实现接口中的方法，这样很多用不到的也要实现很麻烦，所有就有适配类的出现，即用一个抽象类并用抽象类里的空方法体来实现接口中所有方法，然后从这个抽象类中继承，就可以有选择的实现相关方法

代码块

一、代码块: 在程序中(类/方法),使用{}括起来的一段代码.

二、而根据代码块存在的位置,和修饰符,分三类:

   在代码块中定义的变量的的作用范围,就只在该代码块有效.

1):局部代码块:在方法中定义的代码块,一般的表现为if,while,for等语句.

2):初始化代块(构造代码块):在类中直接定义,和方法是平行关系.用来做初始化操作.在创建该初始化代码块所在类的对象的时候,执行,创建N个对象,则执行N次.

     创建对象时,优先于构造器执行.开发中,不推荐使用,即使要在创建对象的时候做初始化操作,我们一般在构造器中完成即可.

3):静态代码块:

  使用static修饰的初始化代码块.

  当静态代码块所在类的字节码被加载进JVM,就立马执行静态代码块,而且只会执行一次.

  一般的,做静态资源的初始化,加载文件,加载资源，静态代码块优先于main方法执行----->main方法,是在字节码被加载进JVM之后,再调用的.

public static void main(String[] args) 
	{
		//代码块
		/*
		{
			int a = 3;
			System.out.println("代码块："+a);
		}
		*/
		//int a = 3;
		//System.out.println(a);
		new TestDemo3();
		new TestDemo3();
		new TestDemo3();


	}
}


class TestDemo3
{
	{	
		System.out.println("普通代码块！");

		}
	//静态代码块，比普通代码块要快，比构造函数要快，并且只会调用一次。
	static{
		System.out.println("静态代码块！");
	}
	public TestDemo3(){
		System.out.println("无参数的构造函数！");
	}
	
}