java编程思想--复用类

Java  /  管理员 发布于 5年前   339

复用类看着标题都不知道是什么,再加上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();//打印输出@Overridepublic 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;@Overridepublic 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;}}// 继承Aclass InitB extends InitA {// 初始化public InitB() {System.out.println("InitB");}{System.out.println("InitB+20");}// static代码块static {System.out.println("InitB+static");}}// 继承InitBpublic 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方法中的输出语句-->方法