java编程思想--复用类

      复用类看着标题都不知道是什么,再加上java编程思想翻译的比价难懂,所以知道现在才看这本软件界的奇书

 

一:组合语法:就是将对象的引用放到新类中即可

    代码:

   

package com.wj.reuse;

/**
 * 
 * @author Administrator 组合类的使用
 */
public class SpringkSystem {
	private String value1, value2, value3, value4;
	private int i;
	private float f;
	//创建对象
	private WaterSource source = new WaterSource();
	//打印输出
	@Override
	public String toString() {

		return 
            "value1=" + value1 + "value2=" + value2  
             + "value3=" + value3+ "value4=" + value4 + "\r\n"             + "i=" + i + "f=" + f + "\r\n"
            + "source=" + source;//对象
	}

	//主函数
	public static void main(String[] args) {
		//创建对象
		SpringkSystem system = new SpringkSystem();
		//输出对象,java中默认输出system.toString();
		//系统会自动的加上toString()
		System.out.println(system);
	}
}

// 内部类
class WaterSource {
	//
	private String s;
      //构造函数
	public WaterSource() {
		System.out.println("WaterSource()");
		s = "Constructed";
	}
	@Override//重写toString()方法
	public String toString() {
		return s;
	}
}

 WaterSource()

 

value1=nullvalue2=nullvalue3=nullvalue4=null

i=0f=0.0

source=Constructed

 

toString();将对象编程一个字符串类型的数据,否则打印的是对象的地址

 

 

二:继承语法

 在java oop中创建的类如果没有使用继承,系统会默认的继承Object类

 

class A{

}

 

class A extends Object{

}

两者都是创建A类 

 

a,继承语法初始化基类

   

package com.wj.reuse;

/**
 * 
 * @author Administrator 继承语法,初始化基类,带参数的构造器
 */

public class DemoExtends extends DemoExtendsMain {

	public static void main(String[] args) {
		//创建对象
		new DemoExtends();
	}
}

//创建基类
class DemoExtendsMain {
	//初始化基类
	DemoExtendsMain() {
		System.out.println("初始化基类");
	}
}

 运行结果: 

 

     初始化基类

 

b:继承语法代参数的构造器

 

package com.wj.reuse;

/**
 * 
 * @author Administrator 继承语法,初始化基类,带参数的构造器
 */

public class DemoExtends extends DemoExtendsMain {

	DemoExtends(int i) {
		super(i);
		// TODO Auto-generated constructor stub
	}

	public static void main(String[] args) {
		//创建对象
		new DemoExtends(5);
	}
}

//创建基类
class DemoExtendsMain {
	//初始化基类
	DemoExtendsMain(int i) {
		System.out.println("带参数的构造器");
	}
}

 运行结果:

 

    带参数的构造器

 

 

三:代理  作者讲的代理就是继承和组合的中庸之道

 

   代理模式的定义：对其他对象提供一种代理以控制对这个对象的访问,相当于操作私有方法

 

a,没有代理模式的:

 

package com.wj.reuse;

/*8
 * java的代理模式的使用
 */
public class ProxyClass extends ProxySon {
	public static void main(String[] args) {
		new ProxyClass().get();
	}

}

// 基类
class ProxySon {
	public void get() {
		System.out.println("基类的方法");
	}
}

 运行结果:

 

  基类的方法

 

b,有代理模式的

 

package com.wj.reuse;

/*8
 * java的代理模式的使用,
 *代理模式 解决了在子类中不能直接操作 而是通过间接的调用,保证了数据的安全性
 */
public class ProxyClass extends ProxySon {
	public static void main(String[] args) {
		// 创建对象,调用代理类的get()方法
		new ProxyClass().Proxyget();
	}

}

// 基类
class Son {
	public void get() {
		System.out.println("基类的方法");
	}
}

// 定义代理的类
class ProxySon {
	// 创建基类
	private Son son = new Son();

	// 创建代理类的方法
	public void Proxyget() {
		// 调用基类的方法
		son.get();
	}
}

 运行结果:

 

   基类的方法

 

分析:

    在没有代理模式中,继承Son类后直接调用get()方法,不利于数据的安全

 

   有代理模式中,使用代理类来操作基类的数据,子类继承代理类,子类在操作中不能够直接操作到数据,必须通过代理类来操作

 

 

四:重写和重载

 

重写:重新覆盖父类的方法

 

package com.wj.reuse;

/*
 * 重写和重载的简单使用
 */

class Demo {// 定义基类
	String s;// 接收参数

	// 定义方法
	public void getSize(String str) {
		s = str;
		System.out.println(s);// 打印
	}
}

// 重写Demo类中的getSize()方法
public class OvverideDemo extends Demo {
	String name;

	@Override
	public void getSize(String name) {
		// super.getSize(str);super是调用父类中的getSize()方法
		this.name = name;
		System.out.println(name);
	}

	// 创建主函数
	public static void main(String[] args) {
		// 创建对象,调用重写的方法
		new OvverideDemo().getSize("java");
	}
}

 运行结果:java

 

 

OvverideDemo继承Demo,并且重写Demo中的getSize()方法;这就是重写

 

重载:方法名相同,参数不同

package com.wj.reuse;

/*8
 * 重载 ,方法名相同,参数不同
 */
//定义基类
class loadeDemo {
	String name;
	int age;
   //定义三个重载的方法
	public void getPeople(String name) {
		this.name = name;
		System.out.println("name:"+name);
	}

	public void getPeople(int age) {
		this.age = age;
		System.out.println("age:"+age);
	}

	public void getPeople(String name, int age) {
		this.name = name;
		this.age = age;
		System.out.println("name:"+name+"   age:"+age);
	}
}

//重载
public class Overloade extends loadeDemo{

	public static void main(String[] args) {
		//创建对象,调用基类的getSize()方法
		new Overloade().getPeople("java",90);
	}
}

 

运行结果:

name:java   age:90

 

五:final关键字

final 类 不能被继承 
final 方法 不能被子类覆盖，但可以继承

package com.wj.reuse;

/*
 * 重写和重载的简单使用
 */

class Demo {// 定义基类
	String s;// 接收参数

	// 使用final 定义方法
	public final void getSize(String str) {
		s = str;
		System.out.println(s);// 打印
	}
}

// 重写Demo类中的getSize()方法
public class OvverideDemo extends Demo {
	String name;
	@Override //基类中使用final定义的方法,子类中是不可以重写(覆盖)
	public void getSize(String name) {//有错
		// super.getSize(str);super是调用父类中的getSize()方法
		this.name = name;
		System.out.println(name);
	}

	// 创建主函数
	public static void main(String[] args) {
		// 创建对象,调用重写的方法
		new OvverideDemo().getSize("java");
	}
}

 
final 变量 只能有一次赋值，赋值后不能改变

 

 

final 不能用来修饰构造方法

 

 

六:继承与初始化

package com.wj.reuse;

//类的继承与初始化

class InitA {// 定义基类

	public InitA() {// 定义构造方法
		System.out.println("InitA");
	}

	// 定义i的值
	public static int i = point();

	public static int point() {
		System.out.println("InitA+point");
		return 1;
	}

}

// 继承A
class InitB extends InitA {
	// 初始化
	public InitB() {
		System.out.println("InitB");
	}

	{
		System.out.println("InitB+20");
	}
	// static代码块
	static {
		System.out.println("InitB+static");
	}

}

// 继承InitB
public class InitDemo extends InitB {
	// 构造方法
	public InitDemo() {
		System.out.println("InitDemo");
	}

	// 代码块输出
	{
		System.out.println("InitDemo+20");
	}

	public static void main(String[] args) {
		// 整型输出
		int n = 10;
		System.out.println(n);
		// 创建对象 输出
		new InitDemo();
		System.out.println("main");
	}
}

 

运行结果:

InitA+point

InitB+static

10

InitA

InitB+20

InitB

InitDemo+20

InitDemo

 

main

 

程序运行时的执行顺序:左边的最先执行  

     static和static代码块-->属性-->非静态代码块--->构造方法-->mian方法中的输出语句-->方法