当前位置:首页 > 开发 > 编程语言 > Java > 正文

java编程思想--复用类

发表于: 2015-03-09   作者:百合不是茶   来源:转载   浏览:
摘要:       复用类看着标题都不知道是什么,再加上java编程思想翻译的比价难懂,所以知道现在才看这本软件界的奇书   一:组合语法:就是将对象的引用放到新类中即可     代码:     package com.wj.reuse; /** * * @author Administrator 组

      复用类看着标题都不知道是什么,再加上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方法中的输出语句-->方法

 

 

 

 

 

 

 

java编程思想--复用类

  • 0

    开心

    开心

  • 0

    板砖

    板砖

  • 0

    感动

    感动

  • 0

    有用

    有用

  • 0

    疑问

    疑问

  • 0

    难过

    难过

  • 0

    无聊

    无聊

  • 0

    震惊

    震惊

编辑推荐
最近在看《Thinking in Java》,看到一个关于内部类的例子,详细如下: class Egg2 { protected cla
第七章 复用类 对于java而言,很重要的都是在讨论复用,高内聚,低耦合,其中复用是我们平时接触的
今天本来以为进度可以快点,但是没想到这么慢,只是今天的知识点比较多。 41-47 多态: 极大的改善我
2012-03-22 54-60/913 第二章 一切都是对象 Java基于C++,但是java是一种更“纯粹”的面向对象程序设
前面的几篇笔记都写得太古板了,今天就换个新的写作风格来试试,暂且叫“案例导向式”吧,希望能对
package com.facaizhu.concurrency; //实现 Runnable,只表示具有一个 run 方法,但它并没有线程能力,
以下内容摘自《java编程思想》第三版: 程序运行时,对象是怎么进行放置安排的呢?特别是内存是怎么
容器类库图 List(interface) 次序是List最重要的特点;它保证维护元素特定的顺序。List为Collection
以下内容摘自《java编程思想》第三版: 程序运行时,对象是怎么进行放置安排的呢?特别是内存是怎么
第一章:对象入门 1.1 、面向对象编程(OOP)的吸引力: (1)对管理人员,它实现了更快和更廉价的
版权所有 IT知识库 CopyRight © 2009-2015 IT知识库 IT610.com , All Rights Reserved. 京ICP备09083238号