4

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());
              }
                    
        }
        }