-------android培训、java培训、java学习型技术博客、期待与您交流！ ------------
1.单例设计模式
设计模式：解决某一类问题最行之有效的方法。
java中有23种设计模式，单例设计模式是解决一个类在内存只存在一个对象。
保证对象唯一：
1.为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象
2.还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。
3.为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。
用代码体现过程：
1.将构造函数私有化。
2.在类中创建一个本类对象。
3.提供一个方法可以获取到该对象。
单例设计模式测试代码示例：
class Student
{
private int age;
private Student(){}//将构造函数私有化
private static Student s = new Student();//在类中创建一个本类对象
public static Student getInstance()//提供一个方法可以获取到该对象
{
return s;
}
public void setAge(int age)
{
this.age = age;
}
public int getAge()
{
return age;
}
}
class SingleDemo
{
public static void main(String[] args)
{
Student s1 = Student.getStudent();
Student s2 = Student.getStudent();
s1.setNum(20);
System.out.println(s2.getNum());//打印结果：20，因为他们是一个对象
}
}
单例设计模式的两种体现：
1.饿汉式(先初始化对象)
class Single
{
private static Single s = new Single();//Single类一进内存，就已经创建好了对象
private Single(){}
public static Single getInstance()
{
return s;
}
}
2.懒汉式(对象的延时加载)
class Single
{
private static Single s = null;//Single类进内存，对象还没有存在
private Single(){}
public static Single getInstance()//调用了getInstance方法时，才建立对象
{
if(s==null)//双重判断
{
synchronized(Single.class)//线程锁
{
if(s==null)
s = new Single();
}
}
return s;
}
}
2.继承的概述
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承单独的那个类即可。
多个类可以称为子类，单独的这个类称为父类或者超类。
子类可以直接访问父类的非私有的属性和行为，通过extends关键字让类与类之间产生继承关系。
class SubDemo extends Demo{}
继承的好处：
1.继承的出现提高了代码的利用性。
2.继承的出现让类与类之间产生了关系，提供了多态的前提。
继承格式示例：
class Person//父类
{
String name;
int age;
}
class Student extends Person//继承父类
{
void study()//子类的功能
{
System.out.println("good study");
}
}
class Worker extends Person//继承父类
{
void work()//子类的功能
{
System.out.println("good work");
}
}
class ExtendsDemo
{
public static void main(String[] args)
{
Student s = new Student();
s.name = "zhagnsan";//继承了父类，直接访问父类的属性
}
}
3.继承的特点
Java只支持单继承，不支持多继承。
一个类只能有一个父类，不可以有多个父类。
class SubDemo extends Demo{}//正确
ass SubDemo extends Demo1,Demo2...//错误
多继承可能带来安全隐患:
当多个父类中定义了相同功能，功能内容却不同时，子类对象不确定要运行哪一个。但是java保留这种机制。并用另一种体现形式来完成表示：多实现。
Java支持多层继承(继承体系)
class A{}
class B extends A{}
class C extends B{}
如何使用一个继承体系中的功能：
1.先查阅体系父类的描述，因为父类中定义的是该体系中共性功能。
2.通过了解共性功能，就可以知道该体系的基本功能。
在具体调用时，为什么要创建最子类的对象：
1.有可能父类不能创建对象。
2.创建子类对象可以使用更多的功能，包括基本的也包括特有的。
定义继承需要注意：
不要仅为获取其他类中某个功能而去继承
类与类之间要有所属(“is a”)关系，xx1是xx2的一种。
4.super关键字
super和this用法相同
this代表本类引用
super代表父类引用
当子父类出现同名成员时，可以用super进行区分
子类要调用父类的构造函数时，可以使用super语句
5.函数覆盖
子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重 写或者复写。
父类中的私有方法不可以被覆盖。
在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取。
覆盖注意事项：
1.覆盖时，子类方法权限一定要大于等于父类方法权限
2.静态只能覆盖静态。
覆盖的应用：当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。
覆盖父类方法测试：
class Fu
{
void show()//父类方法
{
System.out.println("fu show");
}
void speak()//父类方法
{
System.out.println("vb");
}
}
class Zi extends Fu//子继承父
{
void speak()//覆盖父类的方法
{
System.out.println("java");
}
void show()//覆盖父类的方法
{
System.out.println("zi show");
}
}
class ExtendsDemo
{
public static void main(String[] args)
{
Zi z = new Zi();
z.speak();//输出为”java”
}
}
6.子类实例化过程
子类中所有的构造函数默认都会访问父类中空参数的构造函数
因为每一个构造函数的第一行都有一条默认的语句super();
子类会具备父类中的数据，所以要先明确父类是如何对这些数据初始化的。
当父类中没有空参数的构造函数时，子类的构造函数必须通过this或者super语句指定要访问的构造函数。
测试实例化过程代码示例：
class Fu
{
int num ;
Fu()//父类的构造函数
{
num= 60;
System.out.println("fu run");
}
}
class Zi extends Fu//子继承父
{
Zi()//子类的构造函数
{
super();//执行父类的构造函数
System.out.println("zi run");
}
}
class ExtendsDemo
{
public static void main(String[] args)
{
Zi z = new Zi();
System.out.println(z.num);
}
}
运行结果：
fu run
zi run
60
7.final关键字
final可以修饰类，方法，变量。
final修饰的类不可以被继承，为了避免被继承，被子类复写功能。
final修饰的方法不可以被覆盖。
final修饰的变量是一个常量。只能被赋值一次。既可以修饰成员变量，又可以修饰局部变量。
内部类只能访问被final修饰的局部变量。
测试final特性代码示例：
class Demo
{
public static final double PI = 3.14;//final修饰变量变成一个常量，不可以改变
final void show()//修饰方法
{}
}
class SubDemo extends Demo
{
//void show()编译失败，不可继承
}
个人总结：
这节要了解java的设计模式，明确单例设计模式的实现过程，分清单例设计模式的两种体现。要明白继承的概念，java中不能多继承，但支持多层继承，重点掌握继承让类与类实现的是如何的一个关系。掌握子类是怎样的实例化过程，明白子父类中的构造函数执行的先后顺序，必须掌握本节学习的两个关键字：super,final的用法，一定要结合代码去理解。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
