代码改变世界

4

2019-04-29 21:21  luliya  阅读(163)  评论(0编辑  收藏  举报
package ll;

public class Person {
    private String name;
    private int age;
    public Person(){
        
    }
    public Person(int age){
        this.age = age;
    }
    public Person(String name,int age){
        this.name =name;
        this.age=age;
    }
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name=name;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        if(age<0){
            this.age=0;
        }else{
            this.age =age;
        }
    }
    public void printMessage(){
        System.out.println("name ="+name+",age= "+ age);
    }
    public void addAge(){
        age++;
}
}

1)该类包含几个属性?几个构造方法?几个成员方法?

2个属性,4个构造方法,4个成员方法

2)属性、构造方法、成员方法的访问权限修饰符分别是什么?

属性:static,final 构造方法:public,protected,默认,private 成员方法:public和默认

3)什么是方法的重载?此程序,哪几个方法构成了重载?

方法的重载就是在同一个类中允许同时存在一个以上的同名方法,只要这些方法的参数个数或者类型不同即可。

构造方法234   构成了方法的重载

4)为什么要提供getXXX和setXXX方法?

因为我们定义的属性是私有的,我们用get set方法 进行代码的读写。

package ll;

public class TestPerson {


    public static void main(String[] args) {
    Person p1 = new Person("小明",18);
    p1.addAge();
    p1.printMessage();
    
    Person p2 = new Person();
    p2.setName("小小");
    p2.setAge(18);
    p2.printMessage();
    
    Person p3= new Person("小红");
    p3.setAge(20);
    p3.addAge();
    p3.printMessage();

    }

}

1)创建对象时,将自动调用什么方法?

自动调用相对应的构造方法。

2)以上程序创建了三个对象,分别调用的是哪个构造方法?

构造方法4,无参数的构造方法,构造方法2

3)创建对象三时,没有传递参数,请问如何初始化对象呢?请添加初始化对象的代码。

利用set get 初始化数据,代码在上面的程序中,即对象2

4)我想要统计这三个对象中,有多少是成年人(年龄大于等于18岁)并输出人数。请添加相应代码。

package ll;

public class TestPerson {


    public static void main(String[] args) {
        Person a[] = new Person[3];
    a[0]= new Person("小明",18);
    a[0].addAge();
    a[0].printMessage();
    
    a[1] = new Person();
    a[1].setName("小小");
    a[1].setAge(18);
    a[1].printMessage();
    
    a[2]= new Person("小红");
    a[2].setAge(20);
    a[2].addAge();
    a[2].printMessage();
    int j=0;
    for(int i=1;i<4;i++){
    if(a[0].age>=18){
        j++;
    }
}
System.out.println("有"+j+"个成年人");
}

 

  1. 编写“电费管理类”及其测试类。
  • 第一步 编写“电费管理”类
  • 私有属性:上月电表读数、本月电表读数
  • 构造方法:无参、2个参数
  • 成员方法:getXXX()方法、setXXX()方法
  • 成员方法:显示上月、本月电表读数
  • 第二步 编写测试类
  • 创建对象一:上月电表读数为1000,本月电表读数为1200。

   要求:调用无参构造方法创建对象;

         调用setXXX()方法初始化对象;

         假设每度电的价格为1.2元,计算并显示本月电费。

  • 创建对象二:上月电表读数1200,本月电表读数为1450。

   要求:调用2个参数的构造方法创建并初始化对象;

     调用setXXX()方法修改本月电表读数为1500(模拟读错了需修改);

  假设每度电的价格为1.2元,计算并显示本月电费

package lclclc;

public class Ldianfei {
    private double last;
    private double now;
    public Ldianfei(){
    }
    public Ldianfei(double last,double now) {
        this.last=last;
        this.now=now;
    }
    public double getLast() {
        return last;
    }
    public void setLast(double last) {
        this.last=last;
    }
    public double getNow() {
        return now;
    }
    public void setNow(double now) {
        this.now=now;
}
      public void printMessage(){
            System.out.println("上月电表读数"+last+",本月电表读数"+ now);
        }
}
    
package lclclc;

public class TestLdianfei {

    public static void main(String[] args) {
        Ldianfei s1= new Ldianfei();
        s1= new Ldianfei(); 
        s1.setLast(1000);
        s1.setNow(1200);
        s1.printMessage();
        
        s1= new Ldianfei();
        s1.setNow(1200);
        s1.setLast(1000);
        System.out.println("本月电费为:"+(s1.getNow()-s1.getLast())*1.2);
            
        s1=new Ldianfei(1000,1200);
        s1.setNow(1500);
        System.out.println("本月电费为:"+(s1.getNow()-s1.getLast())*1.2);
        
    }

}

3.1 “圆柱体”类

  • 私有属性:圆底半径、高,
  • 构造方法:带两个参数
  • 方法1:计算底面积
  • 方法2:计算体积
  • 方法3:打印圆底半径、高、底面积和体积。

3.2 测试类

  • 创建2个对象,并调用方法
    package lclclc;
    
    public class Lyzt {
        private double r;
        private double h;
        public Lyzt(double r,double h) {
            this.r=r;
            this.h=h;
        }
        public double Lyzts() {    
            double s;
            s=3.14*r*r;
            return s;}
        public double Lyztv() {
            double v;
            v=3.14*r*r*h;
            return v;
        }
         public void printMessage(){
             System.out.println("圆的半径为:"+r);
             System.out.println("圆的高为:"+h);
             System.out.println("圆的底面积为:"+Lyzts());
             System.out.println("圆的体积为:"+Lyztv());
         }
    }
        
    package lclclc;
    
    public class TestLyzt {
    
        public static void main(String[] args) {
        Lyzt s1 =new Lyzt(3,6);
        s1.printMessage();
        
        Lyzt s2 =new Lyzt(4,8);
        s2.printMessage();
        }
    }

  • 4、编写“四则运算类”及其测试类。

    4.1 应用场景

    • 计算器。能实现简单的四则运算,要求:只进行一次运算。

    4.1 “四则运算”类

    • 私有属性:操作数一、操作数二、操作符
    • 构造方法:带两个参数
    • 构造方法:带三个参数
    • 方法一:对两个操作数做加运算
    • 方法二:对两个操作数做减运算
    • 方法三:对两个操作数做乘运算
    • 方法四:对两个操作数做除运算

    4.2 测试类

    • 从键盘输入两个操作数和一个操作符,计算之后,输出运算结果。
    • package lclclc;
      
      public class Lss {
          private int x;
          private int y;
          private char p;
          public Lss(int x,int y) {
              this.x=x;
              this.y=y;
      }
          public Lss(int x,char p,int y) {
              this.x=x;
              this.p=p;
              this.y=y;
      }
          public int Lc() {
              int q ;
              q=x+y;
              return q;
          }
          public int Lcc() {
              int q ;
              q=x-y;
              return q;
          }
          public int Lccc() {
              int q ;
              q=x*y;
              return q;
          }
          public double Lcccc() {
              double q ;
              q=x/y;
              return q;
          }
          }
      package lclclc;
      import java.util.*;
      public class TestLss {
      
          public static void main(String[] args) {
               Scanner rd=new Scanner(System.in);
               System.out.println("请输入两个操作数和一个操作符:");
               int a;
               int b;
               char c;
               a=rd.nextInt();
               c=rd.next().charAt(0);
               b=rd.nextInt();
                Lss s1=new Lss(a,c,b);
                if(c=='+') {
                    System.out.println(s1.Lc());
                    
                }
                if(c=='-') {
                    System.out.println(s1.Lcc());
                    
                }
                if(c=='*') {
                    System.out.println(s1.Lccc());
                    
                }
                if(c=='/') {
                    System.out.println(s1.Lcccc());
                }
                      
          }
          }