java代码的复用性,java方法复用

简述JAVA中继承实现代码复用

看看下面这个例子，就会明白了：JAVA中继承可以实现代码复用，

创新互联建站2013年开创至今，是专业互联网技术服务公司，拥有项目成都网站建设、成都网站制作网站策划，项目实施与项目整合能力。我们以让每一个梦想脱颖而出为使命，1280元前郭做网站,已为上家服务,为前郭各地企业和个人服务,联系电话:18980820575

由于在父类中已经定义的方法，被子类继承以后，就可以使用，实现了代码的复用

class Father{

private int moneyDollar=300;

int moneyHK=200;

int add(int x,int y){

return x+y;

}

}

class Son extends Father{

int moneyRMB=800;

public void changMoneyHK(int x){

moneyHK=x;

}

public void changMoneyRMB(int x){

moneyRMB=x;

}

int subs(int x,int y){

return x-y;

}

}

class GrandSon extends Son{

int multi(int x,int y){

return x*y;

}

}

public class Example5_1{

public static void main(String args[]){

int a=5,b=3;

Son son=new Son();

GrandSon sunzi=new GrandSon();

son.changMoneyHK(666);

son.changMoneyRMB(5000);

System.out.println("儿子的港币是继承的属性,当前的值是:"+son.moneyHK);

System.out.println("儿子的人民币是新增的属性,当前的值是:"+son.moneyRMB);

System.out.printf("减法是儿子新增的功能,%d-%d等于%d\n",a,b,son.subs(a,b));

System.out.printf("加法是儿子继承的功能,%d+%d等于%d\n",a,b,son.add(a,b));

System.out.println("孙子的港币和人民币都是继承的属性,,当前的值是:");

System.out.println("港币:"+sunzi.moneyHK+" 人民币:"+sunzi.moneyRMB);

System.out.printf("乘法是孙子新增的功能,%d*%d等于%d\n",a,b,sunzi.multi(a,b));

System.out.printf("加法是孙子继承的功能,%d+%d等于%d\n",a,b,sunzi.add(a,b));

System.out.printf("减法是孙子继承的功能,%d-%d等于%d\n",a,b,sunzi.subs(a,b));

}

}

Java仅仅有一个参数不一致,如何提高代码复用性

如果你用的是eclipse可以用快捷键来抽取方法的，就是选中重复的代码，然后按alt+shift+m，就解决你的代码重复问题。

java在如下情况怎么实现代码的复用

去掉泛型直接复用就行了。代码貌似有问题

public Kmodel execute(){

ListKmodellist = gethandle();

return list;

}

方法返回的是一个list返回的类型 不是Kmodel或Qmodel

应该是这样吧

public ListKmodel execute(){

ListKmodel list = gethandle();

return list;

}

想复用的话就 去掉泛型应该就能用了。不过取list的元素时需要强制转换类型。

public List execute(){

List list = gethandle();

return list;

}

java中为什么要使用继承

继承： 1，提高了代码的复用性。 2，类与类之间产生了关系，关系的出现，就是多态的由来。

java只支持单继承，不支持不多继承。 原因：当出现多个类中有相同方法时，子类不确定调用的是哪一个。 其实就是父类中的方法有方法体。 但是java支持多层继承。在多层继承中，父类定义都是共性成员。 所体现的内容： 1，父类是不断向上抽取而来的。 2，既然父类体现的共性内容，那么在使用一个继承体系时， 只需要查阅最顶层父类即可了解该体系的基本功能。(查阅API技巧之一) 3，只要建立最子类的对象即可对该继承体系进行应用。

子父类的出现，子类因为持有一个父类引用super，可以获取到父类中非私有的成员。 如同子类中也有一个份一样。

覆盖（复写）override. 对于成员函数，当子父类中出现了一模一样的函数时，会出现一个覆盖操作。 在运行时，会运行子类中的方法。 覆盖注意： 1，子类覆盖父类方法，必须权限大于等于父类。 2，静态覆盖静态。 3，覆盖只发生在函数上。

什么时候使用覆盖呢？ 可以通过覆盖的形式对父类的功能进行重新定义。 比如：对功能进行修改或者对功能进行升级。 注意：不要在子类中定义新功能。还要以父类中的声明为主。

class Demo {

void show() {

System.out.println("Demo show");

}

}

main()

{ //Demo d = new Demo();

SubDemo d = new SubDemo();

d.show();

}

二年后。 为了提高可维护性。 建立一个子类继承Demo，复写其中的某些需要修改的功能即可。

class SubDemo extends Demo {

void show() {

System.out.println("subdemo show");

}

}

super关键字:代表的父类应用。super的应用和this的使用完全一样。

子类的实例化过程： 子类中所有的构造函数回去访问父类中的空参数构造函数。 那是因为：每一个子类构造函数中的第一行都有一个句隐式super()语句。 原理：子类继承父类，获取获取到了父类中的成员，所以子类必须要先明确父类是如何对这些成员进行初始化的。

如何父类中没有了空参数构造函数，需要在子类的构造函数通过super,或者this语句指定要访问的构造函数。

什么时候使用继承呢？ 当类与类之间出现所属(is a)关系时，就使用继承。 类中的所有成员是否可以被另一个类所以拥有. 如果是继承. 如果不是,看是否具备向上抽取的可能. class A {

void method(){}

void function(){}

}

有了一个B类，B中也需要一个method()方法。 这时，是否可以用B继承A来获取这个方法呢？因为这样不是可以提高复用性吗？

那么判断，B和A之间有所属关系吗？不会判断。 这时，可以通过另一个方式，B是否应用具备A中所有功能？ 不是。B只需一个method()方法即可。不需要function()。这样就不需要继承。 但是B中就会重复定义method()方法。 那么A和B出现了共性的内容，就具备了向上抽取的内容。这时A和B就又出现一个父类C。

class B {

void method(){}

void show(){}

}

所以最终设计： class C {

void method(){}

}

class A extends C {

void function(){}

}

class B extends C {

void show(){}

}

----------------------------------------------

final 关键字 1，final可以修饰类，方法，变量。 2，final修饰类不可以被继承，但是可以继承其他类。 3，final修饰的方法不可以被覆盖，但可以覆盖父类方法。 4，final修饰的变量包括成员变量，类变量，局部变量，这些变量只能赋值一次。 5，内部类在局部时，只可以访问被final修饰的局部变量。 通常规范中，被final修饰的变量是一个常量，常量名称所有字母大写。

-----------------------------------------------

抽象类： 分析事物时，发现了共性内容，就出现向上抽取。 会有这样一种特殊情况，就是功能声明相同，但功能主体不同。 那么这时也可以抽取，但只抽取方法声明，不抽取方法主体。 那么该方法就是一个抽象方法。 抽象方法的表现形式：abstract 返回值类型 函数名称(参数列表); 抽象方法一定要存放在抽象类中。

特点： 抽象类不能用new进行实例化。 想要创建对象，必须通过子类复写父类中所有的抽象方法后，该子类才可以创建对象。

抽象类定义时，和一般类一样，都是在描述事物，只不过抽象类可以存放抽象方法，不可以建立对象。

抽象方法的出现可以强迫子类去做某些事。

例：学员类的例子。 学员类的出现其实分析了现实生活中的学生而来的。 张三：躺着睡觉，学习(总结式) 李四：躺着睡觉，学习(机械式)

abstract class 学员 {

void 睡觉(){

躺着睡觉;

}

abstract void 学习();

}

-------------------------------------------- 接口： 简单的理解成抽象类的特殊表现形式，当抽象类的方法全都是抽象的，那么这时就用接口来表示。

特点： -- 接口是对外暴露的规则。 -- 接口是功能的扩展。 -- 接口的出现降低了耦合性。 -- 在java中，多继承的机制被java通过另一种形式来体现，就是多现实。 -- 在java中，一类可以继承一个类的同时，实现多个接口。 例子：主板的pci接口。插座。笔记本电脑的usb接口。

interface 抽烟 {

抽烟方法；

}

class 张三 extends 学员 implements 抽烟 {

void 睡觉(){

躺着睡觉;

}

void 学习(){}

抽烟方法{}

}

接口中通常的定义的内容： 1，全局常量。public static final 2，公有的抽象方法。 public abstract

类与类之间是继承关系。

类与接口之间是实现关系。

接口与接口之间是继承关系，而且，接口之间存在多继承

java 为什么要实现 function？

java是一个面向对象的编程语言，类包括属性和行为，其中的行为就是有function实现的，所以对象需要实现行为才能算是健壮的对象，非常重要，下面学习的一些内容，希望能帮到你。

数据的连接首先需要加载一个代码块。如果 chunk 是一个字符串，代码块指这个字符串。如果 chunk 是一个函数， load 不断地调用它获取代码块的片段。 每次对 chunk 的调用都必须返回一个字符串紧紧连接在上次调用的返回串之后。 当返回空串、nil、或是不返回值时，都表示代码块结束。

1.如果没有语法错误， 则以函数形式返回编译好的代码块； 否则，返回 nil 加上错误消息。

如果结果函数有上值， env 被设为第一个上值。 若不提供此参数，将全局环境替代它。 所有其它上值初始化为 nil。 （当你加载主代码块时候，结果函数一定有且仅有一个上值 _ENV ））。 然而，如果你加载一个用函数（参见 string.dump， 结果函数可以有任意数量的上值） 创建出来的二进制代码块时，所有的上值都是新创建出来的。 也就是说它们不会和别的任何函数共享。

2.接下来就是根据以上信息进行下面的操作，chunkname 在错误消息和调试消息中，用于代码块的名字。 如果不提供此参数，它默认为字符串chunk 。 chunk 不是字符串时，则为 "=(load)" 。

字符串 mode 用于控制代码块是文本还是二进制（即预编译代码块）。 它可以是字符串 "b" （只能是二进制代码块）， "t" （只能是文本代码块）， 或 "bt" （可以是二进制也可以是文本）。 默认值为 "bt"。

3.Lua 不会对二进制代码块做健壮性检查。 恶意构造一个二进制块有可能把解释器弄崩溃。

运行程序来遍历表中的所有域。 第一个参数是要遍历的表，第二个参数是表中的某个键。 next 返回该键的下一个键及其关联的值。 如果用 nil 作为第二个参数调用 next 将返回初始键及其关联值。 当以最后一个键去调用，或是以 nil 调用一张空表时， next 返回 nil。 如果不提供第二个参数，将认为它就是 nil。 特别指出，你可以用 next(t) 来判断一张表是否是空的。

索引在遍历过程中的次序无定义， 即使是数字索引也是这样。 （如果想按数字次序遍历表，可以使用数字形式的 for 。）

4.当在遍历过程中你给表中并不存在的域赋值， next 的行为是未定义的。 然而你可以去修改那些已存在的域。 特别指出，你可以清除一些已存在的域。

如果 t 有元方法 __pairs， 以 t 为参数调用它，并返回其返回的前三个值。

否则，返回三个值：next 函数， 表 t，以及 nil。 因此以下代码

能迭代表 t 中的所有键值对。

参见函数 next 中关于迭代过程中修改表的风险。

pcall (f [, arg1, ···])

5.传入参数，以 保护模式 调用函数 f 。 这意味着 f 中的任何错误不会抛出； 取而代之的是，pcall 会将错误捕获到，并返回一个状态码。 第一个返回值是状态码（一个布尔量）， 当没有错误时，其为真。 此时，pcall 同样会在状态码后返回所有调用的结果。 在有错误时，pcall 返回 false 加错误消息。

希望能帮到你，谢谢！

网页名称：java代码的复用性,java方法复用
网站路径：http://mswzjz.cn/article/dsiijop.html