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