java之 ------ 类的封装、继承和多态(三)

问题:声明复数类,成员变量包括实部和虚部,成员方法包括实现由字符串构造复数、复数加法、减法、字符串描述、比较相等等操作。

声明复数类如下

public class Complex {
    public double real,imag;                       //实部,虚部

    public Complex(double real, double imag)        //构造方法
    public Complex(double real)                   //构造方法重载
    public Complex()                            //构造方法
    public Complex(String s)               //构造方法,由字符串构造复制对象
    public Complex(Complex c)            //拷贝构造方法,复制对象
    public String toString()                 //对象的字符串描述,
    public double getModel()               //返回复数对象的模
    public void add(Complex c)             //两个对象相加,改变当前对象
    public static Complex add(Complex c1, Complex c2)    //返回两个对象相加后的对象,重载
    public void subtract(Complex c)                     //两个对象相减,改变当前对象
    public static Complex subtract(Complex c1, Complex c2)  //返回两个对象相减后的对象,重载
    public boolean equals(Object obj)                    //比较两个对象是否相等
}

代码实现:

import java.util.*;
class ComplexNumber{
	int really,virtual;
	public ComplexNumber(int a,int b){
		this.set(a,b);
	}
	public ComplexNumber(){
	}
	public ComplexNumber(String str){
		this.set(str);
	}
	public void set(String str){
		if(str.length()==0){
			return ;
		}
		boolean isVirtualNegat=false;
		boolean isReallyNegat=false;
		int[] a=new int[2];
		int k=0;
		for(int i=0;i<str.length();i++){
			if(str.charAt(i)=='i'){
				break;
			}
			if(str.charAt(i)=='+'||str.charAt(i)=='-'){
				if(i!=0){
					k++;
				}
				if(str.charAt(i)=='-'){
					if(i==0){
						isReallyNegat=true;
					}else{
						isVirtualNegat=true;
					}
				}
				continue;
			}
			a[k]=a[k]*10+str.charAt(i)-'0';
		}
		if(isVirtualNegat){
			a[1]*=-1;
		}
		if(isReallyNegat){
			a[0]*=-1;
		}
		this.set(a[0],a[1]);
	}
	public void set(int a,int b){
		this.really=a;
		this.virtual=b;
	}
	public boolean equals(ComplexNumber x){
		if(x.really==this.really&&x.virtual==this.virtual){
			return true ;
		}
		return false;
	}
	public ComplexNumber add(ComplexNumber x){
		ComplexNumber sum=new ComplexNumber();
		sum.really=this.really+x.really;
		sum.virtual=this.virtual+x.virtual;
		return sum;
	}
	public ComplexNumber minus(ComplexNumber x){
		ComplexNumber sum=new ComplexNumber();
		sum.really=this.really-x.really;
		sum.virtual=this.virtual-x.virtual;
		return sum;
	}
	public int  compleTo(ComplexNumber x){
		if(this.really>x.really){
			return 1;
		}else if(this.really==x.really){
			if(this.virtual>x.virtual){
				return 1;
			}else if(this.virtual==x.virtual){
				return 0;
			}else{
				return -1;
			}
		}else{
			return -1;
		}
	}
	public String toString(){
		if(this.virtual<0){
			if(this.really==0){
				return this.virtual+"i";
			}
			return this.really+"-"+-1*this.virtual+"i";
		}else if(this.virtual==0){
			return this.really+"";
		}else{
			if(this.really==0){
				return this.virtual+"i";
			}
			return this.really+"+"+this.virtual+"i";
		}
	}
}
class Main{
	public static void main(String[] args){
		Scanner sc=new Scanner(System.in);
		System.out.println("Please input two number`s really part and virtual part:");
		int reall1=sc.nextInt(),virtual1=sc.nextInt();
		int reall2=sc.nextInt(),virtual2=sc.nextInt();
		ComplexNumber a=new ComplexNumber(reall1,virtual1);
		ComplexNumber b=new ComplexNumber(reall2,virtual2);
		//System.out.println(a+" "+b);
		System.out.println("("+a+")"+" + ("+b+") = ("+a.add(b)+")");
		System.out.println("("+a+")"+" - ("+b+") = ("+a.minus(b)+")");
		if(a.compleTo(b)==0){
			System.out.println(a+" = "+b);
		}else if(a.compleTo(b)==1){
			System.out.println(a+" > "+b);
		}else{
			System.out.println(a+" < "+b);
		}
		System.out.println("-------------------");

		System.out.println("Please input two complex-number : ");
		String x=sc.next();
		String y=sc.next();
		ComplexNumber c=new ComplexNumber(x);
		ComplexNumber d=new ComplexNumber(y);
		System.out.println("("+c+")"+" + ("+d+") = ("+c.add(d)+")");
		System.out.println("("+c+")"+" - ("+d+") = ("+c.minus(d)+")");
		if(c.compleTo(d)==0){
			System.out.println(c+" = "+d);
		}else if(c.compleTo(d)==1){
			System.out.println(c+" > "+d);
		}else{
			System.out.println(c+" < "+d);
		}
	}
}
时间: 2024-08-23 21:19:01

java之 ------ 类的封装、继承和多态(三)的相关文章

黑马程序员--oc 类的封装 继承 和多态

------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 成员变量的命名规范: 成员变量名要以 _开头 作用: 1.可以让成员变量和get方法的名称区分开 2.可以和局部变量区分开,一看到以_开头的变量一般都是成员变量 封装: 在定义成员变量时,尽量不要用@public 这种写法 ,而是使用set方法和get方法 @interface Student : NSObject { int _age; } /* set方法: 作用:提供一个方法给外界设置成

类的封装 继承和多态

package 银行账户管理;import java.text.SimpleDateFormat;   //常用日期操作工具类import java.util.Calendar;     //使用默认时区和语言环境获得一个日历import java.util.Date;public class yinhang {  private String acount;     //账户  private String name;   //姓名  private String time;   //时间  

(1) 深入理解Java面向对象三大特性 封装 继承 多态

转眼已经工作快6年了,最开始做了2年J2EE:然后整了2年的数据仓库,主要是Cognos的报表开发:现在从事4G LTE核心网的开发,用的语言任然是Java,但写代码的机会不多,基本都是看代码找BUG,偶尔做点new feature也是在比较成熟的框架上复制.粘贴.修改,大部分时间还是在理解业务,钱多.事少.离家近,当时来这家公司图的是后面2点,2年过去了,英文水平有所提升,对敏捷开放也有一定的了解,但技术方面明显退步了或者说没有进步吧,本来以前也不怎么好,因为工作上用不到,自己也没怎么学习,所

day33 序列类型,绑定方法,类方法,静态方法,封装继承和多态

Python之路,Day20 = 序列类型,绑定方法,类方法,静态方法,封装继承和多态 序列是指有序的队列,重点在"有序". 一.Python中序列的分类 Python中的序列主要以下几种类型: 3种基本序列类型(Basic Sequence Types):list.tuple.range 专门处理文本的附加序列类型(Text Sequence Types):str 专门处理二进制数据的附加序列类型(Binary Sequence Types): bytes.bytearray.mem

Mysql数据库大量删除操作及谈面向对象中的封装继承和多态原理(图)

Mysql数据库大量删除操作及谈面向对象中的封装继承和多态原理(图)最近进行数据库操作,遇到一个问题,就是大量删除一个数据表中的数据后,由于设定了id是自增的,导致再插入时,默认生成的id会很大,这个时候想要再次插入新的数据,应该怎么办呢?1.明确目前最后一个id的大小select id from tags order by id DESC limit 0,1; 假设返回的是9,则设置数据表从10开始自增 2.修改这个数据表从10开始自增alter table tags auto_increme

java类的封装 继承 多态

1.猜数字小游戏 package cn.jiemoxiaodi_02; import java.util.Scanner; /** * 猜数字小游戏 * * @author huli * */ public class GuessNumberDemo { public static void main(String[] args) { int number = (int) (Math.random() * 100) + 1; while (true) { System.out.println("

JAVA的三大特征 封装继承多态- 简单总结

简单总结一下 封装-即从很多类的抽取相同的代码 写在一个类里. 好处是 代码的重用,安全. 继承-减少代码的书写. 其好处也是 代码的重用. 多态- 把不同的子类对象都当作父类来看,可以屏蔽不同子类对象之间的差异,写出通用的代码,做出通用的编程,以适应需求的不断变化. 总的来说还是接口的重用. 那么总结一下,JAVA的三大特征 其好处 就是代码与接口的重用. 封装可以隐藏实现细节,使得代码模块化: 继承可以扩展已存在的代码模块(类): 它们的目的都是为了——代码重用. 而多态则是为了实现另一个目

Java面向对象三大特性 封装 继承 多态

1.封装 封装的定义: 首先是抽象,把事物抽象成一个类,其次才是封装,将事物拥有的属性和动作隐藏起来,只保留特定的方法与外界联系 为什么需要封装: 封装符合面向对象设计原则的第一条:单一性原则,一个类把自己该做的事情封装起来,而不是暴露给其他类去处理,当内部的逻辑发生变化时,外部调用不用因此而修改,他们只调用开放的接口,而不用去关心内部的实现 举例: public class Human { private int age; private String name; public int get

面向对象:封装继承和多态、接口

1.多态 定义:不同对象对于同一个方法(Cut)调用表现出不同行为多态性主要是靠重写和隐藏来实现 a.(父类引用指向子类对象)b.(父类类型做参数,传递子类对象)自定义方法参数是父类类型 传递的实参是子类对象c.(父类类型作返回类型,return子类对象)自定义方法的返回类型是父类类型,return是类对象注:都是把子类对象赋给父类类型 举例: 添加乐器类using System;using System.Collections.Generic;using System.Linq;using S

四. Java继承和多态8.Java final关键字:阻止继承和多态

在 Java 中,声明类.变量和方法时,可使用关键字 final 来修饰.final 所修饰的数据具有"终态"的特征,表示"最终的"意思.具体规定如下: final 修饰的类不能被继承. final 修饰的方法不能被子类重写. final 修饰的变量(成员变量或局部变量)即成为常量,只能赋值一次. final 修饰的成员变量必须在声明的同时赋值,如果在声明的时候没有赋值,那么只有 一次赋值的机会,而且只能在构造方法中显式赋值,然后才能使用. final 修饰的局部变