java中 3 6_java基础复习3-6

设计模式

设计模式：解决某一类问题最行之有效的方法。

java中23种设计模式：

单例设计模式：解决一个类在内存只存在一个对象。

想要保证对象唯一。

1，为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象。

2，还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。

3，为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

这三步怎么用代码体现呢？

1.将构造函数私有化。

2.在类中创建一个本类对象。

3.提供一个方法可以获取到该对象。

对于事物该怎么描述，就还怎么描述。当需要将该事物的对象保证在内存中唯一时，就将以上的三步加上即可。

饿汉式，懒汉式：

记录原则：定义单例，建议使用饿汉式。

/*//饿汉式：这个是先初始化对象,Single类一进内存，就已经创建好了对象。

class Single{

private static Single s=new Single();

private Single(){}

public static Single getInstance(){

return s;

}

}

*/

//懒汉式：对象是方法被调用时，才初始化，也叫做对象的延时加载。

//Single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象。

class Single2 {

private static Single2 s = null;

private Single2() {}

public static Single2 getInstance() {

if (s == null)

s = new Single2();

return s;

}

}

继承：

java语言中：java只支持单继承，不支持多继承。

因为多继承容易带来安全隐患：当多个父类中定义了相同功能，当功能内容不同时，子类对象不确定要运行哪一个，但是java保留了这种机制，并用另一种体现形式来完成表示，多实现。

java支持多层继承，也就是一个继承体系

如何使用一个继承体系中的功能呢？

简单一句话：查阅父类功能，创建子类对象使用功能。

想要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中共性功能，通过了解共性功能，就可以知道该体系的基本功能。那么这个体系已经可以基本使用了。那么在具体调用时，要创建最子类的对象，为什么呢？一是因为有可能父类不能创建　　　　对象，二是创建子类对象可以使用更多的功能，包括基本的也包括特有的。

this代表的是本类对象的引用。

super代表的是父类对象的引用。

改写老代码很麻烦，不如自己直接继承然后复写来的方便简单。

final:最终：

作为一个修饰符。

1，可以修饰类，函数，变量。

2，被final修饰的类不可以被继承。为了避免被继承，被子类复写功能。

3，被final修饰的方法不可以被复写。

4，被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，又可以修饰局部变量。

当在描述事物时，一些数据的出现数值是固定的，那么这时为了增强阅读性，都给这些值起个名字，方便于阅读。而这个值不需要改变，所以加上final修饰。作为常量：常量的书写规范所有字母都大写，如果由多个单词组成，单词间通过“_”连接。

5，内部类定义在类中的局部位置上是，只能访问该局部被final修饰的局部变量。

abstract

当多个类中出现相同的功能，但是功能主体不同，这时可以进行向上抽取，这时，只抽取功能定义，而不抽取功能主体。

抽象：看不懂。

抽象类的特点：

1，抽象方法一定在抽象类中。

2，抽象方法和抽象类都必须被abstract关键字修饰。

3，抽象类不可以用new创建对象，因为调用抽象方法没意义。

4，抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。

抽象类和一般类没有太大的不同。

该如何描述事物就如何描述事物，只不过，该事物出现了一些看不懂的东西，这些不确定的东西，也是该事物的功能，需要明确出现。但是无法定义主体，通过抽象方法来表示。

抽象类比一般类多了个抽象函数，就是在类中可以定义抽象方法，抽象类不可以实例化。

特殊：抽象类不可以定义抽象方法，这样做仅仅是不让该类建立对象。

接口：初期理解，可以认为是一个特殊的抽象类

当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。

class用于定义类

interface用于定义接口

接口定义时，格式特点：

1，接口中常见定义：常量，抽象方法。

2，接口中的成员都有固定修饰符。

常量：pubic static final

方法：public abstract

记住：接口中的成员都是public的。

接口：是不可以创建对象的，因为有抽象方法。

需要被子类实现，子类对接口中的抽象方法全部覆盖后，子类才可以实例化。否则子类是一个抽象类。

接口可以被类多实现，也是对多继承不支持的转换形式，java支持多实现。

多态：可以理解为事物存在的多种体现形态。

1，多态的体现

父类的引用指向了自己的子类对象。

父类的引用也可以接收自己的子类对象。

2，多态的前提

必须是类与类之间有关系，要么继承要么实现。

通常还有一个前提：存在覆盖。

3，多态的好处

多态的出现大大的提高程序的扩展性。

4，多态的弊端：

提高了扩展性，但是只能使用父类的引用访问父类中的成员。

5，多态的应用

6，多态的出现代码中的特点(多态使用的注意事项)

在多态中成员函数的特点：

在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。

在运行时期：参阅对象所属的类中是否有调用的方法。

简单的总结就是：成员函数在多态调用时，编译看左边，运行看右边。

在多态中，成员变量的特点：

无论编译和运行，都参考左边(引用型变量所属的类)。

/*需求：数据库的操作。

数据是：用户信息。

1.连接数据库。JDBC Hibernate

2.操作数据库。c create r read u update d delete

3.关闭数据库。*/

//定义这个接口

interface UserInfoDao {

public void add(User user);

public void delete(User user);

}

//byJDBC

class UserInfoByJDBC implements UserInfoDao {

public void add(User user){

1，JDBC连接数据库 。

2，使用sql添加语句添加数据。

3，关闭连接。

}

public void delete(User user){

1,JDBC连接数据库。

2，使用sql添加语句删除数据。

3，关闭连接。

}

}

//byHibernate

class UserInfoByHibernate implements UserInfoDao{

public void add(User user){

1，Hibernate连接数据库。

2，使用sql添加语句添加数据。

3，关闭连接。

}

public void delete(User user){

1，Hibernate连接数据库。

2，使用sql添加语句删除数据。

3，关闭连接。

}

}

//选用JDBC还是Hibernate

class DBOperate {

public static void main(String[] args) {

UserInfoDao ui = new UserInfoByJDBC();

ui.add(user);

ui.delete(user);

}

}

(晴，写于7月13日，广州，转载请标明出处，谢谢)