----------- android培训、java培训、java学习型技术博客、期待与您交流! ------------
(一)设计模式
(一)设计模式
设计模式:对普遍常见问题,通用的解决办法。
23种。其实就是解决问题的思想。
单例设计模式:
解决的问题:保证一个类在内存中的对象唯一性。
如何保证一个类的对象唯一性呢?
思路:
1,不让其他程序创建该类对象。
2,其他程序不能创建,只有在本程序中创建一个对象。
3,将自定义的对象提供给其他程序访问。
步骤:
1,私有化构造函数。
2,自己new一个本类对象。
3,对外提供一个方法可以获取到这个对象。
方式一:
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);
}
}