第五章 面向对象三

1.static关键字

1.static：静态的，可用来修饰属性，方法，代码块，内部类

2.static修饰属性（类变量）：

①由类创建的所有的对象，都共用这一个属性

②当其中一个对象对此属性进行修改，会导致其他对象对此属性的一个调用。vs实例变量（非static修饰的属性，各个对象各自拥有一套副本）

③类变量随着类的加载而加载。而且独一份

④静态的变量可以直接通过“类.类变量”的形式来调用

⑤类变量的加载是要早于对象，所以当有对象以后，可以“对象.类变量”使用。但是“类.实例变量”是不行的

⑥类变量存在于静态域中

   static修饰方法（类方法）：

①随着类的加载而加载，在内存中也是独一份

②可以直接通过“类.类方法”的方式调用

③内部可以调用静态的属性或静态的方法，而不能调用非静态的属性或方法，反之，非静态的方法是可以调用静态的属性或静态的方法

   >静态的方法内是不可以有this或super关键字的

注：静态的结构（static的属性、方法、代码块、内部类）的生命周期要早于非静态的结构，同时被收回也晚于非静态的结构

单例模式：

23种设计模式

单例模式：

解决的问题：如何只让设计的类只能创建一个对象

如何实现：饿汉式&懒汉式

//饿汉式1

class Bank{

//1.私有化构造器

private Bank(){}

//2.创建类的对象，同时设置为private的，通过公共的方法来调用，体现封装性

//4.要求此对象也为static的

private static  Bank instance = new Bank();

//3.此公共的方法，必须为static

public static Bank getInstance(){

return instance;

}

}

//饿汉式2

class Bank{

//1.私有化构造器

private Bank(){}

//2.创建类的对象，同时设置为private的，通过公共的赖调用，体现封装性

//4.要求此对象也为static的

private static Bank instance =null;

static{

instance = new Bank();

}

//3.此公共的方法，必须为static

public static Bank getInstance(){

return instance;

}

}

//懒汉式 

class Bank{

private Bank(){}

private static Bank instance = null;

public static Bank getInstance(){

if(instance == null){//可能存在线程安全问题

instance = new Bank();

}

return instance;

}

}

2.main()方法：

public static void main(String[] args){

//方法体

}

1.main()是一个方法，主方法，为程序的入口

2.public ：权限修饰符 protected 缺省 private        面向对象的封装性

3.static ：对于方法来讲 ，修饰符 static final abstract

4.void 方法的返回值：void/具体的返回值类型（基本&引用），方法内部一定要有return

5.方法名：命名规则：xxxYyyZzz，给方法命名时，见名知意

6.形参列表:同一方法名不同的形参列表的诸多个方法构成重载 。形参&实参---方法的参数传递机制：值传递

7.方法体：方法定义的是一种功能，具体的实现由方法体操作。

3.代码块

代码块/初始化快：类的第四个成员

作用：用来初始化类的属性

分类：只能用static修饰

静态代码块&非静态代码块

静态代码块：

1)里面可以有输出语句

2)随着类的加载而加载，而且只被加载一次

3)多个静态代码块之间按照顺序结构执行

4)静态代码块的执行要早于非静态代码块的执行

5)静态代码块只能执行静态的结构（类属性、类方法）

非静态代码块：

1)可以对类的属性（静态的&非静态的）进行初始化操作，同时也可以调用本类声明的方法（静态的&非静态的）

2)里面可以有输出语句

3)一个类中可以有多个非静态的代码块，多个代码块之间按照顺序结构执行

4)每创建一个类的对象，非静态代码块就加载一次

5)非静态代码块的执行要早于构造器

属性赋值：①默认的初始化②显式的初始化或代码块初始化（此处两个结构按照顺序执行）③构造器中④通过方法对对象的相应属性进行修改

①②③是对象属性初始化的过程

4.final关键字：

final：最终的 用来修饰类、属性、方法

1.final修饰类：这个类就不能被继承。如：String类、StringBuffer类、System类

2.final修饰属性：此属性就是一个常量，一旦初始化后，不可再被赋值。习惯上，常量用大写字符表示。

   此常量在哪里赋值：①此常量不能使用默认初始化②可以显式的赋值、代码块、构造器

3.final修饰方法：不能被重写。如：Object类的getClass()

常量用static final修饰：全局常量 比如Math类的PI

5.抽象类abstract：

abstract:抽象的，可以用来修饰类、方法

1.abstract修饰类：抽象类

1)不可被实例化

2)抽象类有构造器（凡是类都有构造器）

3)抽象方法所在的类，一定是抽象类

4)抽象类中可以没有抽象方法

>当我们设计一个类，不需要创建此类的实例的时候，就可以考虑将其设置为抽象的，由子类实现这个类的抽象方法以后，进行实例化

2.abstract修饰方法：抽象方法

1)格式：没有方法体，包括{}。如：public abstract void eat()；

2)抽象方法只保留方法的功能，而具体的执行，交给继承抽象类的子类，由子类重写此抽象方法

3)若子类继承抽象类，并重写了所有的抽象方法，则此类是一个“实体类”，可以实例化

4)若子类继承抽象类，没有重写所有的抽象方法，意味着此类中仍有抽象方法，则此类必须声明为抽象的

当设计一个类 不需要此类的实例 考虑设置为抽象的 由其子类实现其抽象方法

模板方法设计模式（TemplateMethod）

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。

解决的问题：

1.当功能内部一部分实现是确定，一部分实现是不确定的，这时可以吧不确定的部分暴露出去，让子类去实现。

2.编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，就是一种模板模式。

例子： 

//模板方法设计模式

public class TestTemplate {

public static void main(String[] args) {

new SubTemplate().spengTime();

}

}

abstract class Template{

abstract void code();

public void spengTime(){

long start = System.currentTimeMillis();

code();

long end = System.currentTimeMillis();

System.out.println("花费的时间为： " + (end - start));

}

}

class SubTemplate extends Template{

public void code(){

boolean flag = false;

for(int i = 2;i <= 10000;i++){

for(int j = 2;j <= Math.sqrt(i);j++){

if(i % j == 0){

flag = true;

break;

}

}

if(!flag){

System.out.println(i);

}

flag = false;

}

}

}

6.接口：

接口（interface）是与类并行的一个概念

1.接口可以看做是一个特殊的抽象类，是常量与抽象方法的一个集合，不能包含变量、一般的方法

2.接口没有构造器

3.接口定义的就是一种功能，此功能可以被类所实现（implements）。如：class CCextends DD implements AA

4.实现接口的类，必须要重写其中的所有的抽象方法，方可实例化，若没有重写所有的抽象方法，则此类仍为一个抽象类

5.类可以实现多个接口。-----java中的类的继承是单继承的

6.接口与接口之间也是继承的关系，而且可以实现多继承

> 5，6描述的是java中继承的特点

7.接口与具体实现类之间也存在着多态性

8.面向接口编程的思想

接口用法的总结：

1.通过接口可以实现不相关类的相同行为，而不需要考虑这些类之间的层次关系

2.通过接口可以指明多个类需要实现的方法，一般用于定义对象的扩张功能

3.接口主要用来定义规范，解除耦合关系

工厂方法的设计模式

概述：

定义一个用于创建对象的接口，让子类决定实例化哪一个类。

FactoryMethod使一个类的实例化延迟到子类

适用性：

1.当一个类不知道它所必须创建的对象的类的时候

2.当一个类希望由它的子类来指定它所创建的对象的时候

3.当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候     

//工厂方法的设计模式 例子

public class TestFactoryMethod {

public static void main(String[] args) {

IWorkFactory i = new StudentWorkFactory();

i.getWork().doWork();

IWorkFactory i1 = new TeacherWorkFactory();

i1.getWork().doWork();

}

}

interface IWorkFactory{

Work getWork();

}

class StudentWorkFactory implements IWorkFactory{

@Override

public Work getWork() {

return new StudentWork();

}

}

class TeacherWorkFactory implements IWorkFactory{

@Override

public Work getWork() {

return new TeacherWork();

}

}

interface Work{

void doWork();

}

class StudentWork implements Work{

@Override

public void doWork() {

System.out.println("学生写作业");

}

}

class TeacherWork implements Work{

@Override

public void doWork() {

System.out.println("老师批改作业");

}

}

代理模式 

概述：为其他对象提供一种代理以控制这个对象的访问

//代理模式  （静态代理）

public class TestProxy {

public static void main(String[] args) {

Object obj = new ProxyObject();

obj.action();

}

}

interface Object{

void action();

}

//代理类

class ProxyObject implements Object{

Object obj;

public ProxyObject(){

System.out.println("代理类创建成功");

obj = new ObjectImpl();

}

public void action(){

System.out.println("代理类开始执行");

obj.action();

System.out.println("代理类执行结束");

}

}

//被代理类

class ObjectImpl implements Object{

@Override

public void action() {

System.out.println("被代理类开始执行");

System.out.println("具体操作");

System.out.println("被代理类执行完毕");

}

}

7.内部类：

类的第五个成员：内部类

1.相当于说，我们在类的内部再定义类。外面的类：外部类。里面定义的类：内部类

2.内部类的分类：成员内部类（声明在类内部且方法外的） vs 局部内部类（声明在类的方法里）

3成员内部类：

  1) 是外部类的一个成员：①可以有修饰符（四个）②static final ③可以调用外部类的属性、方法

  2)具体类的特点：①abstract ②还可以在其内部定义属性、方法、构造器

4.局部内部类：

常常使用一个方法，使其返回值为某个类或接口的对象，而这个类或者接口在方法内部创建

文件名：外部类名称$内部类名称.class     

5.匿名内部类：new [类或接口]{//实现}

文件名：外部类名称$编号.class  

6.关于内部类，要掌握：

①如何创建成员内部类的对象

②如何区分调用外部类、内部类的变量

③局部内部类的使用

本文出自 “阿成的博客” 博客，转载请与作者联系！

JavaSE基础笔记六