黑马程序员 Java基础<二>设计模式、继承等概念

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

(一)设计模式

设计模式：对普遍常见问题，通用的解决办法。
          23种。其实就是解决问题的思想。

单例设计模式：
    解决的问题：保证一个类在内存中的对象唯一性。


如何保证一个类的对象唯一性呢？

思路：
1，不让其他程序创建该类对象。
2，其他程序不能创建，只有在本程序中创建一个对象。
3，将自定义的对象提供给其他程序访问。


步骤：
1，私有化构造函数。
2，自己new一个本类对象。
3，对外提供一个方法可以获取到这个对象。
方式一:

//饿汉式
class Single
{
	//创建一个本类对象。
	private static Single s = new Single();

	//私有化构造函数。
	private Single(){}

	//对外提供方法，让其他程序获取该对象。
	//结果？Single
	//参数/ 无。
	public static Single getInstance()
	{
		return s;
	}
}

class SingleDemo 
{
	public static void main(String[] args) 
	{
		Single s1 = Single.getInstance();
		Single s2 = Single.getInstance();
		System.out.println(s1==s2);
	}
}

方式二:

//懒汉式，延迟加载方式。
//存在一些小问题，这是涉及到多线程技术的。
class Single
{
	private static Single s = null;
	private Single(){}

	public static Single getInstance()
	{
		if(s==null)
			s = new Single();
		return s;
	}
}


class Single2
{
	private static final Single2 s =  new Single2();
	private Single2(){}
	
	public static Single2 getInstance()
	{
		return s;
	}
	/**/
}
class SingleDemo2 
{
	public static void main(String[] args) 
	{
		
//		Single2 s1 = Single2.s;
//		Single2 s2 = Single2.s;

//		System.out.println(s1==s2);
	}
}

(二)继承

当两个事物之间存在一定的所属关系，即就像孩子从父母那里得到遗传基因一样，当然，java要遗传的更完美，这两个类中，一个继承的类（为子类或者基础类）可以从被继承的类（为父类或者超类）中获得一些属性和方法，而不必再自己创建新方法（在不需要复写的情况等）。

一、特点：

1、提高代码复用性，定义在父类中的成员（变量和方法），可以被子类重复使用；

2、让类与类之间产生关系，这样就会有多态的特性。使得应用起来更方便。

需要注意的是：

A.不可以只是为了获取其他类的功能，简化代码就一味的使用继承；必须是类与类之间有所属关系，才可以用继承，这种关系称为“is-a”。

B.java语言中，只支持单继承，不支持多继承。究其原因，是因为多继承容易带来安全隐患：

a.当多个父类中定义了相同的功能，且功能内容不同时，子类对象并不确定要运行哪一个，这就造成了程序的混乱而导致异常出现。

b但是java保留了这种机制，并改良了多继承为多实现，而且接口就可以多继承。

二、使用继承体系中的功能

1、如果使用体系，要先对体系中父类的描述进行参阅，了解父类中的共性功能，即可以使用该体系了。这样既可以减少查阅时间，也能更系统的了解体系结构，以及父类的功能。

2、具体调用父类中的功能的时候，需要创建子类对象，通过子类对象对父类方法调用，实现继承。

为何要通过创建子类对象调用父类中的方法呢？原因如下：

a.父类很可能不可以创建对象，如父类是一个抽象类或者接口，这就需要子类创建对象，调用方法。

b.创建子类对象，可以使用更多的功能，如父类公有的，和子类中自定义的特有功能。

三、子父类出现后，类成员的特点：

类成员：变量、函数、构造函数

1、变量：

子父类中出现非私有的同名成员变量是，子类访问本类的同名时，要用this关键字（如果省略了this，仍是代表本类的变量）；子类访问父类同名变量时，用super关键字。

补充：this和super 两者都存在与方法区中。

    this：本类对象引用，那个对象调用this所在的函数，this就代表那个对象。

    super：父类对象引用，用于子类初始化父类构造函数时等。

2、.函数：（覆盖（重写））

当子类同父类出现相同函数时，子类对象调用该函数时，会运行子类内容，如同覆盖谷类函数一样。实际上并没有覆盖父类的函数，如果还需要调用父类的这个方法，需要用super.方法名即可。

/*
继承：提高了代码的复用性。
	  让类与类之间产生了关系，给多态这个特征提供了前提。


特点：
1，java中不直接在类上体现多继承。只支持单继承。
多继承：一个子类可以继承多个父类。
class Fu1
{
	void show(){}
}
class Fu2
{
	void show(){}
}

class Zi extends Fu1,Fu2
{
}
new Zi().show();//出现了调用的不确定性。在方法体上不确定。

单继承：一个子类只能继承一个父类。


多层继承：就会出现继承体系，学习一个体系的时候，先看最顶层的类。使用最底层的类创建对象调用方法。



什么时候写继承？
事物之间存在着所属(is a)关系时，才继承。xxx是yyy中的一种。
xxx继承yyy。
比如：狗继承犬科，狼继承犬科。



*/

class Person
{
	private String name;
	int age;
	public String getName()
	{
		return this.name;
	}
}


class Student extends/*继承*/Person
{
	void study()
	{
		System.out.println(getName()+":"+age+" good good study...");
	}
}


class Worker extends Person
{
	
	void work()
	{
		System.out.println(name+":"+age+"....work");
	}
}


class ExtendsDemo 
{
	public static void main(String[] args) 
	{
		Student s = new Student();
//		s.name="李四";
		s.age=12;
		s.study();
	}
}

/*
继承中，子类里，成员的特点。
成员变量。

成员函数。

构造函数。

*/

//成员变量。
/*
super关键字：
super关键字的用法和this相似。

this代表的是当前对象。
super代表的是父类中内存空间。

子父类中不会出现同名属性的情况。

*/

class Fu
{
	int num = 4;

}
class Zi extends Fu
{
	int num = 5;
	void show()
	{
		int num = 6;
		System.out.println("num="+super.num);
		System.out.println(this);
//		System.out.println(super);//不可以。
	}
}
class ExtendsDemo2 
{
	public static void main(String[] args) 
	{
		new Zi().show();
	}
}

/*
继承中，成员函数的特点。

特殊情况：
子父类中出现了一模一样的方法，创建子类对象调用该方法时，运行的是子类中的方法。
这种情况称之为函数的另一个特性----覆盖(override)重写 复写。


继承的覆盖使用注意事项：

1，子类覆盖父类权限必须大于等于父类的权限。
2，覆盖中，静态只能覆盖静态，或者被静态覆盖。




*/

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

class Zi extends Fu
{
	public void show()
	{
		System.out.println("zi show");
	}
}

class ExtendsDemo3 
{
	public static void main(String[] args) 
	{
		Zi z = new Zi();
		z.show();
//		Phone p = new Phone();
//		NewPhone p = new NewPhone();
//		p.show();
	}
}


/*

覆盖的应用。

新电话的功能
来电显示 除了号码，还显示姓名，大头贴。

*/
class Phone
{
	public void call(){}
	//来电显示。
	public void show()
	{
		System.out.println("number");
	}

}
//新电话描述。
/*
覆盖的应用:沿袭父类的功能声明，定义子类该功能的特有内容。

*/
class NewPhone extends Phone
{
	public void show()
	{
//		System.out.println("number");
		super.show();
		System.out.println("name");
		System.out.println("pic");
	}
}

/*
子父类中的构造函数的特点。

创建子类对象，父类中的构造函数也运行了。
为什么呢？
其实在子类的所有构造函数中的第一行，都有一句默认的super();在调用父类中的空参数构造函数。
为什么子类实例化都必须去父类中的初始化呢？
因为子类继承了父类，只有了父类中的内容，所以子类在实例化使用父类中的内容之前，
必须要先明确父类是如何对自己的内容进行初始化的，
所以子类的构造函数都会默认访问父类中空参数的构造函数。通过super();

如果父类中没有空参数的构造函数时，子类的构造函数必须通过super执行要访问的父类中的构造函数。


this()和super();都必须出现在构造函数的第一行。
为什么都必须出现的第一行呢？因为初始化的动作要先执行。



*/
class Fu extends Object
{
	Fu()
	{
		//super();
		//显示初始化。
		//构造代码块初始化。
		System.out.println("fu run...");
	}
	/**/
	Fu(int x)
	{
		System.out.println("fu ..."+x);
	}
}
class Zi extends Fu
{
	Zi()
	{
//		super();
		
		System.out.println("Zi run...");
	}
	Zi(int x)
	{
		this();
		System.out.println("Zi ..."+x);
	}
}

class ExtendsDemo4 
{
	public static void main(String[] args) 
	{
		new Zi(4);
	}
}