黑马程序员__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的用法，一定要结合代码去理解。