2020.8.17

一、今日学习内容

1、多继承客货两用车

 1 //接口1：Car
 2 public interface Car {
 3     public void setCar(int p,int s);
 4     public void show1();
 5 }
 6 //接口2:Wagon
 7 public interface Wagon {
 8     public void setWagon(int p,int l);
 9     public void show2();
10 }
11 //实现类：
12 public class StationWagon implements Car,Wagon{
13     private int power,seat,load;
14     public void setCar(int p,int s) {
15         power=p;
16         seat=s;
17     }
18     public void show1() {
19         System.out.println("car power:"+power);
20         System.out.println("seat:"+seat);
21     }
22     public void setWagon(int p,int l) {
23         power=p;
24         load=l;
25     }
26     public void show2() {
27         System.out.println("wagon power:"+power);
28         System.out.println("load:"+load);
29     }
30     public void show() {
31         System.out.println("Sation Wagon:");
32     }
33     public static void main(String[] args) {
34         StationWagon SW=new StationWagon();
35         SW.setCar(200,9);
36         SW.setWagon(200, 100);
37         SW.show();
38         SW.show1();
39         SW.show2();
40     }
41 }

2、定义一个Point类，有两个数据成员：x和y, 分别代表x坐标和y坐标，并有若干成员函数。定义一个友元函数Distance(), 用于求两点之间的距离。

 1 import  java.util.Scanner;
 2 public class Point {
 3   private double x; 
 4   private double y; 
 5   public void input() {
 6       Scanner in=new Scanner(System.in);
 7       this.x=in.nextDouble();
 8       this.y=in.nextDouble();
 9   }
10   public double getX() {
11       return this.x;
12   }
13   public double getY() {
14       return this.y;
15   }
16   public void distance(Point p) {
17       double d;
18       d=Math.sqrt((x-p.x)*(x-p.x)+(y-p.y)*(y-p.y));
19       System.out.printf("%.2f",d);
20   }
21   public static void main(String[] args) {
22       Point p1=new Point();
23       Point p2=new Point();
24       System.out.print("请输入点1：");
25       p1.input();
26       System.out.print("请输入点2：");
27       p2.input();
28       p1.distance(p2);
29   }
30 }

3、复数类

声明一个复数类Complex（类私有数据成员为double型的real和image）

定义构造函数，用于指定复数的实部与虚部。

定义取反成员函数，调用时能返回该复数的相反数（实部、虚部分别是原数的相反数）。

定义成员函数Print()，调用该函数时，以格式(real, image)输出当前对象。

编写加法友元函数，以复数对象c1，c2为参数，求两个复数对象相加之和。

主程序实现：

（1）读入两个实数，用于初始化对象c1。

（2）读入两个实数，用于初始化对象c2。

（3）计算c1与c2相加结果，并输出。

（4）计算c2的相反数与c1相加结果，并输出。

 1 //复数类
 2 import java.util.Scanner;
 3 public class Complex {
 4   private double real; // 实部
 5   private double image; // 虚部
 6   //无参构造函数
 7   public Complex() {
 8   }
 9   //有参构造函数
10   public Complex(double real, double image) {
11       this.real = real;
12       this.image = image;
13   }
14   //取反成员函数
15   public Complex oppo() {
16       double a=-this.real;
17       double b=-this.image;
18       Complex result=new Complex(a,b);
19       return result;
20   }
21   //输出复数
22   public void print() {
23       System.out.println("("+real+","+image+")");
24   }
25   // 复数的加法
26   public static Complex add(Complex c1,Complex c2) {
27       double real1 = c1.real;
28       double image1 = c1.image;
29       double real2=c2.real;
30       double image2=c2.image;
31       double a = real1 + real2;
32       double b = image1 + image2;
33       Complex c = new Complex(a, b);
34       return c;
35   }
36   public static void main(String[] args) {
37       Scanner in=new Scanner(System.in);
38       System.out.print("请输入复数1的实部和虚部：");
39       double a1=in.nextDouble();
40       double a2=in.nextDouble();
41       Complex c1=new Complex(a1,a2);
42       System.out.print("请输入复数2的实部和虚部：");
43       double b1=in.nextDouble();
44       double b2=in.nextDouble();
45       Complex c2=new Complex(b1,b2);
46       Complex m=new Complex();
47       Complex n=new Complex();
48       m=add(c1,c2);
49       System.out.println("复数1+复数2：");
50       m.print();
51       n=add(c1,c2.oppo());
52       System.out.println("复数1+复数2的相反数：");
53       n.print();
54   }
55 }

二、遇到的问题

没有遇到什么问题

三、明日计划

继续完成相关例题