您的位置:首页 > 运维架构 > Linux

win8下使用vagrant安装部署Linux虚拟环境出错的问题解决

2015-01-01 16:27 645 查看
第五章 面向对象三

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.关于内部类,要掌握:
①如何创建成员内部类的对象
②如何区分调用外部类、内部类的变量
③局部内部类的使用

本文出自 “阿成的博客” 博客,转载请与作者联系!
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: 
相关文章推荐