黑马程序员__JAVA基础__面向对象(二)

-------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的用法，一定要结合代码去理解。