【面向对象小练习】封装

最新推荐文章于 2023-04-02 09:06:58 发布

待会吃什么啊

最新推荐文章于 2023-04-02 09:06:58 发布

阅读量1.4k

点赞数

文章标签： servlet java junit

本文链接：https://blog.csdn.net/qq_49047454/article/details/126056177

版权

知识点

面向对象

基础+拓展

1.基础编程题

题目1（训练）

定义手机类，手机有品牌(brand),价格(price)和颜色(color)三个属性，有打电话call()和sendMessage()两个功能。

请定义出手机类，类中要有空参、有参构造方法，set/get方法。

定义测试类，在主方法中使用空参构造创建对象，使用set方法赋值。

调用对象的两个功能，打印效果如下：

//测试类
public class demo3 {
    public static void main(String[] args) {
        Phone phone = new Phone();//使用空参构造创建对象
        phone.setBrand("小米");//使用set方法赋值
        phone.setColor("黑色");
        phone.setPrice(3998);
        phone.call();//调用对象的两个功能
        phone.sendMessage();
    }
}

//定义手机类
public class Phone {
    //手机有品牌(brand),价格(price)和颜色(color)三个属性
   private String brand;
    private int price;
    private String color;
    //空参构造方法
    public Phone(){

    }
    //有参构造方法
    public Phone(String brand,int price,String color){
        this.brand = brand;
        this.price = price;
        this.color = color;
    }
    //set/get方法
    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getBrand() {
        return brand;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getColor() {
        return color;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public int  getPrice() {
        return price;
    }
    //有打电话call()和sendMessage()两个功能
    public void call(){
        System.out.println("正在使用价格为"+price+"元"+color+"的"+brand+"打电话....");
    }
    public  void  sendMessage(){
        System.out.println("正在使用价格为"+price+"元"+color+"的"+brand+"发信息....");
    }
}

正在使用价格为3998元黑色的小米手机打电话....
正在使用价格为3998元黑色的小米手机发短信....

训练提示

类中的属性就是成员变量，类中的行为功能就是成员方法。
成员变量要被private修饰。

解题方案

操作步骤

定义手机类，手机类中定义String类型的品牌，int类型的价格，String类型的颜色，三个成员变量都用privice修饰。
提供空参构造方法和有参构造方法。
提供set/get方法。
编写打电话的成员方法，方法中对成员变量进行使用。
编写发短信的成员方法，方法中对成员变量进行使用。
在测试类中创建手机对象，使用set方法赋值，分别调用各个方法。

参考答案

手机类：
public class Phone {
    //定义品牌
    private String brand;
    //定义价格
    private int price;
    //定义颜色
    private String color;

    //提供空参构造
    public Phone() {
    }
    //提供有参构造
    public Phone(String brand, int price, String color) {
        this.brand = brand;
        this.price = price;
        this.color = color;
    }
    //提供set/get方法
    public String getBrand() {
        return brand;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(int price) {
        this.price = price;
    }
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    //定义打电话方法
    public void call(){
        System.out.println("正在使用价格为"+price+"元"+color+"的"+brand+"手机打电话....");
    }
    //定义发短信方法
    public void sendMessage(){
        System.out.println("正在使用价格为"+price+"元"+color+"的"+brand+"手机发短信....");
    }
}

测试类：
public class Demo1 {
    public static void main(String[] args) {
        //创建手机对象
        Phone p = new Phone();
        //调用set方法赋值
        p.setBrand("小米");
        p.setPrice(3998);
        p.setColor("黑色");
        //调用打电话功能
        p.call();
        //调用发短信功能
        p.sendMessage();
    }
}

题目2（训练）

定义一个女朋友类。女朋友的属性包含：姓名，身高，体重。行为包含：洗衣服wash()，做饭cook()。另外定义一个用于展示三个属性值的show()方法。请在测试类中通过有参构造方法创建对象并赋值，然后分别调用展示方法、洗衣服方法和做饭方法。打印效果如下：

//测试类
public class demo3 {
    public static void main(String[] args) {
        //通过有参构造方法创建对象并赋值
        GirlFriend girlFriend = new GirlFriend("凤姐",155,130);
        //调用展示方法、洗衣服方法和做饭方法
        girlFriend.show();
        girlFriend.wash();
        girlFriend.cook();
    }
}

//定义一个女朋友类
public class GirlFriend {
    //女朋友的属性包含：姓名，身高，体重
    private String name;
    private double high;
   private double weight;
    //行为包含：洗衣服wash()，做饭cook()
    public void wash(){
        System.out.println("女朋友帮我洗衣服");
    }
    public void cook(){
        System.out.println("女朋友帮我做饭");
    }
    //定义一个用于展示三个属性值的show()方法
    public void show(){
        System.out.println("我女朋友叫"+name+"身高"+high+"厘米，体重"+weight+"斤");
    }
    //有参构造方法
    public GirlFriend(String name,double high,double weight){
        this.high=high;
        this.name=name;
        this.weight=weight;
    }
       //空参构造
    public Girlfriend() {
    }
}

我女朋友叫凤姐,身高155.0厘米,体重130.0斤
女朋友帮我洗衣服
女朋友给我做饭

训练提示

类中的属性就是成员变量，类中的行为功能就是成员方法。
成员变量要被private修饰。
展示方法的作用就是打印姓名、身高、体重三个成员变量的值。

解题方案

操作步骤

定义女朋友类，定义String类型姓名，double类型身高和double类型体重三个成员变量，三个成员变量都用privice修饰。
提供空参构造方法和有参构造方法。
提供set/get方法。
编写展示方法show()，方法打印三个成员变量的值。
编写洗衣服wash()方法，输出洗衣服的语句。
编写做饭cook()方法，输出做饭的语句。
在测试类中使用有参构造创建女友对象，分别调用各个方法。

参考答案

女朋友类：
public class Girlfriend {
    //姓名
    private String name;
    //身高
    private double height;
    //体重
    private double weight;
    //空参构造
    public Girlfriend() {
    }
    //有参构造
    public Girlfriend(String name, double height, double weight) {
        this.name = name;
        this.height = height;
        this.weight = weight;
    }
    //set/get方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getHeight() {
        return height;
    }
    public void setHeight(double height) {
        this.height = height;
    }
    public double getWeight() {
        return weight;
    }
    public void setWeight(double weight) {
        this.weight = weight;
    }
    //展示方法
    public void show(){
        System.out.println("我女朋友叫" +name+",身高" +height+"厘米,体重"+weight+"斤");
    }
    //洗衣服方法
    public void wash(){
        System.out.println("女朋友帮我洗衣服");
    }
    //做饭方法
    public void cook(){
        System.out.println("女朋友给我做饭");
    }
}
测试类：
public class Demo2 {
    public static void main(String[] args) {
        //创建女朋友对象
        Girlfriend gf = new Girlfriend("凤姐",155,130);
        //调用展示方法
        gf.show();
        //调用洗衣服方法
        gf.wash();
        //调用做饭方法
        gf.cook();
    }
}

题目3（训练）

定义项目经理类Manager。属性：姓名name，工号id，工资salary，奖金bonus。行为：工作work() 定义程序员类Coder。属性：姓名name，工号id，工资salary。行为：工作work()

要求：

1.按照以上要求定义Manager类和Coder类,属性要私有,生成空参、有参构造，set和get方法 2.定义测试类,在main方法中创建该类的对象并给属性赋值(set方法或有参构造方法) 3.调用成员方法,打印格式如下:

//测试类
public class demo3 {
    public static void main(String[] args) {
        //通过有参构造方法创建对象并赋值
        Manager manager = new Manager("项目经理",123,15000,6000);
       //通过set方法方法创建对象并赋值
        Coder coder = new Coder();
        coder.setId(135);
        coder.setName("程序员");
        coder.setSalary(10000);
        //调用成员方法
        manager.work();
        coder.work();
    }
}

//定义项目经理类Manager
public class  Manager{
    //属性：姓名name，工号id，工资salary，奖金bonus,属性要私有
    private String name;
    private int id;
    private int salary;
    private int bonus;
    //行为：工作work()
    public void work(){
        System.out.println("工号为"+id+"基本工资为"+salary+"奖金为"+bonus+"的"+name+"正在努力的做着管理工作,分配任务,检查员工提交上来的代码.....");
    }
    //空参、有参构造
    public Manager(){

    }
    public Manager(String name,int id,int salary,int bonus){
        this.bonus=bonus;
        this.id=id;
        this.salary=salary;
        this.name=name;
    }
//set和get方法
    public void setBonus(int bonus) {
        this.bonus = bonus;
    }

    public int getBonus() {
        return bonus;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }

    public int getSalary() {
        return salary;
    }
}

//定义程序员类Coder
public class Coder{
    //属性：姓名name，工号id，工资salary,属性要私有
 private String name;
 private int id;
 private int salary;
 //行为：工作work()
    public void work(){
        System.out.println("工号为"+id+"基本工资为"+salary+"的"+name +"正在努力的写着代码......");
    }
 //生成空参、有参构造
    public Coder(){}
    public Coder(String name,int id,int salary){
        this.salary=salary;
        this.id=id;
        this.name=name;
    }
    //set和get方法

    public void setSalary(int salary) {
        this.salary = salary;
    }

    public int getSalary() {
        return salary;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }
}

工号为123基本工资为15000奖金为6000的项目经理正在努力的做着管理工作,分配任务,检查员工提交上来的代码.....
工号为135基本工资为10000的程序员正在努力的写着代码......

训练提示

类中的属性就是成员变量，类中的行为功能就是成员方法。
成员变量要被private修饰。
在工作work()方法中调用成员变量，输出成员变量的值。

解题方案

操作步骤

定义项目经理类，定义成员变量，构造方法，set和get方法，work方法，方法中根据打印格式输出id,salary,bonus的值。
定义程序猿类，定义成员变量，构造方法，set和get方法，work方法，方法中根据打印格式输出id和salary的值。
在测试类中使用有参构造创建项目经理对象并赋值，调用工作方法打印结果。
在测试类中使用有参构造创建程序员对象并赋值，调用工作方法打印结果。

参考答案

经理类:
public class Manager {
    private String name;
    private int id;
    private int salary;
    private int bonus;
    public Manager() {
    }
    public Manager(String name, int id, int salary, int bonus) {
        this.name = name;
        this.id = id;
        this.salary = salary;
        this.bonus = bonus;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public int getSalary() {
        return salary;
    }
    public void setSalary(int salary) {
        this.salary = salary;
    }
    public int getBonus() {
        return bonus;
    }
    public void setBonus(int bonus) {
        this.bonus = bonus;
    }
    public void work(){
        System.out.println("工号为"+id+"基本工资为"+salary+"奖金为"+bonus+"的项目经理正在努力的做着管理工作,分配任务,检查员工提交上来的代码.....");
    }
}
程序员类：
package com.day07;

public class Coder {
    private String name;
    private int id;
    private int salary;
    public Coder() {
    }
    public Coder(String name, int id, int salary) {
        this.name = name;
        this.id = id;
        this.salary = salary;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public int getSalary() {
        return salary;
    }
    public void setSalary(int salary) {
        this.salary = salary;
    }
    public void work(){
        System.out.println("工号为"+id+"基本工资为"+salary+"的程序员正在努力的写着代码......");
    }
}
测试类：
public class Demo3 {
    public static void main(String[] args) {
        //创建经理对象
        Manager m = new Manager("老王",123,15000,6000);
        //调用工作方法
        m.work();
        //创建程序员对象
        Coder c = new Coder("小王",135,10000);
        //调用工作方法
        c.work();
    }
}

题目4（训练）

定义猫类Cat。属性:毛的颜色color，品种breed。行为:吃饭eat()，抓老鼠catchMouse() 定义狗类Dog。属性:毛的颜色color，品种breed。行为:吃饭()，看家lookHome() 要求: 1.按照以上要求定义Cat类和Dog类,属性要私有,生成空参、有参构造，set和get方法 2.定义测试类,在main方法中创建该类的对象并给属性赋值(set方法或有参构造方法) 3.调用成员方法,打印格式如下:

花色的波斯猫正在吃鱼.....
花色的波斯猫正在逮老鼠....
黑色的藏獒正在啃骨头.....
黑色的藏獒正在看家.....

训练提示

类中的属性就是成员变量，类中的行为功能就是成员方法。
成员变量要被private修饰。

解题方案

操作步骤

定义猫类，定义成员变量，构造方法，set和get方法，吃饭方法eat()，抓老鼠方法catchMouse()，方法中根据题目给出的格式输出成员变量的值。
定义狗类，定义成员变量，构造方法，set和get方法，吃饭方法eat()，看家方法lookHome()，方法中根据题目给出的格式输出成员变量的值。
在测试类中使用有参构造创建猫类对象，调用eat()方法和catchMouse()方法。
在测试类中使用有参构造创建狗类对象，调用eat()方法和lookHome()方法。

参考答案

猫类：
public class Cat {
    private String color;
    private String breed;
    public Cat(){}
    public Cat(String color, String breed) {
        this.color = color;
        this.breed = breed;
    }
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public String getBreed() {
        return breed;
    }
    public void setBreed(String breed) {
        this.breed = breed;
    }
    public void eat(){
        System.out.println(color+"的"+breed+"正在吃鱼.....");
    }
    public void catchMouse(){
        System.out.println(color + "的"+ breed +"正在逮老鼠....");
    }
}
狗类：
public class Dog {
    private String color;
    private String breed;
    public Dog(){}
    public Dog(String color, String breed) {
        this.color = color;
        this.breed = breed;
    }
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public String getBreed() {
        return breed;
    }
    public void setBreed(String breed) {
        this.breed = breed;
    }
    public void eat(){
        System.out.println(color + "的"+ breed +"正在啃骨头.....");
    }
    public void lookhome(){
        System.out.println(color + "的"+ breed +"正在看家.....");
    }
}
测试类：
public class Demo4 {
    public static void main(String[] args) {
        //创建猫对象
        Cat c = new Cat("花色","波斯猫");
        //调用猫的方法
        c.eat();
        c.catchMouse();
        //创建狗对象
        Dog d = new Dog("黑色","藏獒");
        d.eat();
        d.lookhome();
    }
}

2.扩展作业：

题目5

编写一个：

属性：课程名；学时；任课老师；

创建五个对象：“c语言”，“java编程”，“php网络编程”，“c++”，“数据结构”

提供无参的构造器和一个有参的构造器

//测试类
public class demo3 {
    public static void main(String[] args) {
        //通过有参构造方法创建对象并赋值
        Course course = new Course("C语言",3,"小红");
        Course course1 = new Course("java编程",3,"小红");
        Course course2 = new Course("php网络编程",3,"小红");
        Course course3 = new Course("c++",3,"小红");
        Course course4 = new Course("数据结构",3,"小红");
       //调用方法输出
        course.show();
        course1.show();
        course2.show();
        course3.show();
        course4.show();
    }
}

//定义课程类
public class  Course{
  //属性：课程名；学时；任课老师
    private String course;
    private int period;
    private  String teacer;
    //无参的构造器
   public Course(){}
 //有参的构造器
   public Course(String course,int period,String teacer){
     this.course=course;
     this.period=period;
     this.teacer=teacer;
   }
//set/get方法
    public void setCourse(String course) {
        this.course = course;
    }

    public String getCourse() {
        return course;
    }

    public void setPeriod(int period) {
        this.period = period;
    }

    public int getPeriod() {
        return period;
    }

    public void setTeacer(String teacer) {
        this.teacer = teacer;
    }

    public String getTeacer() {
        return teacer;
    }
    //show()方法
    public void show(){
        System.out.println(course+",学时为"+period+",任课老师是"+teacer);
    }
}

题目6（训练）

定义一个类，用于描述坐标点

0——————>X

| P(X,Y)

（1）具有计算当前点到原点距离的功能

（2）求到任意一点（m，n）的距离

（3）求到任意一点（Point p）的距离

（4）具有坐标点显示功能，显示格式（x，y）

（5）提供无参的构造器和一个有参的构造器

//测试类
public class demo3 {
    public static void main(String[] args) {
        //通过有参构造方法创建对象并赋值
        Coordinate p = new Coordinate(2, 3);
        p.distanceToOrigin();
        p.distanceToArbitraryPoint();
        p.show();
    }
}

import java.util.Scanner;

//定义类
public class  Coordinate{
 //定义属性
 private double x;
 private double y;
 //无参构造
 public Coordinate(){}
//有参构造
 public Coordinate(double x,double y){
  this.x=x;
  this.y=y;
 }
//set/get方法
 public void setX(double x) {
  this.x = x;
 }
 public double getX() {
  return x;
 }
 public void setY(double y) {
  this.y = y;
 }
 public double getY() {
  return y;
 }
 //show()方法
 public void show(){
  System.out.println("该点与x轴距离为"+Math.abs(y)+",与y轴距离为"+Math.abs(x)+".格式为("+x+","+y+")");
 }
 //计算当前点到原点距离
 public void distanceToOrigin(){
  double distance=Math.sqrt(x*x+y*y);
  System.out.println("该点到原点的距离为："+distance);
 }
 //任意一点（m，n）的距离
Scanner sc= new Scanner(System.in);
 public void distanceToArbitraryPoint(){
  System.out.println("请输入任意一点横坐标和纵坐标");
  double m=sc.nextDouble();
  double n=sc.nextDouble();
  double M=m>=0?m:(-m);
  double N=n>=0?n:(-n);
  double X=x>=0?x:(-x);
  double Y=y>=0?y:(-y);
  double distance=Math.sqrt((M-X)*(M-X)+(N-Y)*(N-Y));
  System.out.println("任一点（"+m+","+n+")到点（"+x+","+y+")的距离为"+distance);
 }
}

题目7

编程创建一个Box类，在其中定义三个变量表示一个立方体的长、宽和高，定义一个方法求立方体的体积。创建一个对象，求给定尺寸的立方体的体积。

（提供无参的构造器和一个有参的构造器）

//测试类
public class demo3 {
    public static void main(String[] args) {
        //通过有参构造方法创建对象并赋值
        Box box = new Box(3,2,1);
        box.v();
    }
}

//定义类
public class Box {
 //定义属性
private  int len;
private  int wid;
private int hig;
//无参的构造器
public Box(){}
//有参的构造器
public Box(int len,int wid,int hig){
    this.hig=hig;
    this.len=len;
    this.wid=wid;
}
//定义一个方法求立方体的体积
public void v(){
    double v=len*wid*hig;
    System.out.println("体积为"+v);
}
//set/get方法

    public void setHig(int hig) {
        this.hig = hig;
    }

    public int getHig() {
        return hig;
    }

    public void setLen(int len) {
        this.len = len;
    }

    public int getLen() {
        return len;
    }

    public void setWid(int wid) {
        this.wid = wid;
    }

    public int getWid() {
        return wid;
    }
}

题目8

写一个汽车类：

属性：品牌；车长；颜色；价格；

创建五个对象：“捷达”，“宝马”，“劳斯莱斯”，“科鲁兹”，“迈锐宝”

提供无参的构造器和一个有参的构造器

题目9

写出以下程序的执行结果

public class Test1 {

    public static void main(String[] args) {
        new A(new B());
    }
}
class A{
    public A(){
        System.out.println("A");
    }
    public A(B b){   2.
        this();//?????  ---A
        System.out.println("AB");  AB
    }
}
class B{
    public B(){
        System.out.println("B"); 1. B
    }
}

B
A
AB

题目10（选择题）

？？？写出程序的执行结果()

class Value{

  int i = 15;

}

class Test{

public static void main(String argv[]) {

Test t = new Test();

t.first();

}

 

public void first() {

int i = 5;

Value v = new Value();

v.i = 25;

second(v, i);

System.out.println(v.i);

}

 

public void second(Value v, int i) {

i = 0;

v.i = 20;

Value val = new Value();

v = val;

System.out.print(v.i + " " + i); //15  //0 

}

}

！！！ A.15 0 20

B.15 0 15

C.20 0 20

D.0 15 20

题目11（构造器）

//(1)定义Student类,有4个属性：
String name;
int age;
String school;
String major;
//(2)定义Student类的3个构造器:
第一个构造器Student(String n, int a)设置类的name和age属性；
第二个构造器Student(String n, int a, String s)设置类的name, age 和school属性；
第三个构造器Student(String n, int a, String s, String m)设置类的name, age ,school和major属性；
//(3)在main方法中分别调用不同的构造器创建的对象，并输出其属性值。

//测试类
public class demo3 {
    public static void main(String[] args) {
        //通过有参构造方法创建对象并赋值
        Student student = new Student("小王",21,"MBI","ds");
        Student student1= new Student("小王",21,"MBI");
        Student student2= new Student("小王",21);
        student.show();
        student1.show();
        student2.show();
    }
}

//定义类
public class Student {
 //定义属性
    String name;
    int age;
    String school;
    String major;
//无参的构造器
public Student(){}
//有参的构造器
public Student(String n, int a){
    name=n;
    age=a;
}
 public Student(String n, int a,String s){
        name=n;
        age=a;
        school=s;
    }
 public Student(String n, int a,String s, String m){
        name=n;
        age=a;
       school=s;
       major=m;
    }
public void show(){
    System.out.println(name+" "+age+" "+school+" "+major);
}

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void setMajor(String major) {
        this.major = major;
    }

    public String getMajor() {
        return major;
    }

    public void setSchool(String school) {
        this.school = school;
    }

    public String getSchool() {
        return school;
    }
}

知识点

String 基础点练习

画出如下几行代码的内存（堆栈）结构：

String s1 = "hello";

String s2 = "hello";

String s3 = new String("hello");

s1 += “world”;

如何理解String类的值不可变但可以共享？

字符串不可变，它们的值在创建后不能被更改

以“ ” 方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次，JVM 都只会建立一个 String 对象，

String s = new String(“hello”);在内存中创建了几个对象？请说明

2个第一个:字面量"hello" ---java会创建一个String对象表示字面量"hello"，并将其存入常量池第二个:new String() ---new String()时会再创建一个字符串对象，并引用hello字符串的内容

“用运算符“==”比较字符串对象时，只要两个字符串包含的是同一个值，结果便为 true。”这句话对吗？

不对，比较基本数据类型：比较的是具体的值

比较引用数据类型：比较的是对象地址值

String的常用方法有哪些？它们分别是什么意思？（至少7个）

public boolean equals(Object anObject) 比较字符串的内容，严格区分大小写

public char charAt(int index) 返回指定索引处的 char 值

public int length() 返回此字符串的长度

trim()：去除字符串两端的空格；

toLowerCase()：将字符串转换为小写字母；

toUpperCase()：将字符串转换为大写字母；

equalsIgnoreCase(String)：忽略大小写比较两个值是否相等

题目1（训练）

现已知工人（Worker）类，属性包含姓名（name）、工龄（year），请编写该类，提供构造方法和get、set方法。在测试类中，请查看键盘录入Scanner类的API，创建工人类对象，属性值由键盘录入，打印对象的属性值。输出效果如下：

请录入工人姓名：
张三
请录入工人工龄：
5
该工人对象的属性信息如下：
姓名：张三
工龄：5

//测试类
public class demo3 {
    public static void main(String[] args) {
        //通过有参构造方法创建对象并赋值
        Worker worker = new Worker();
        worker.setName();
        worker.setYear();
        worker.show();
    }
}


import java.util.Scanner;

//定义类
public class Worker {
    //定义属性
    private String name;
    private int year;
    //无参构造
    public Worker(){}
    //有参构造
    public Worker(String name,int year){
       this.name=name;
       this.year=year;
    }
    //键盘录入
    Scanner sc=new Scanner(System.in);
    public void setName() {
        System.out.println("请录入工人姓名");
        name=sc.next();
        this.name = name;
    }

    public String getName() {
        return name;
    }
Scanner sc1=new Scanner(System.in);

    public void setYear() {
        System.out.println("请录入工人工龄");
        year=sc1.nextInt();
        this.year = year;
    }

    public int getYear() {
        return year;
    }
    public void show(){
        System.out.println("该工人对象的属性信息如下：\n" +
                "姓名："+name+"\n" +
                "工龄："+year+"\n");
    }

训练目标

编写简单的java类，创建对象，查询API。

训练提示

1、怎样编写一个标准的描述工人的类？

2、创建工人对象时需要两个属性信息，由键盘录入，该使用哪个API？

3、创建对象之后，显示对象的属性信息，该调用哪个方法？

参考方案

训练步骤

1、创建Worker类，成员变量私有修饰，提供空参和全参构造方法，提供get和set方法。

2、创建Test01类，在主方法中，创建键盘录入Scanner对象。

2.1、姓名信息为字符串，使用Scanner的nextLine()方法。

2.2、工龄信息为整数，使用Scanner的nextInt()方法。

3、创建Worker类对象，并输出对象的成员变量值。

3.1、可以在创建对象时使用构造方法为成员变量赋值，也可以创建对象后使用set方法赋值。

3.2、获取成员变量的值，使用get方法。

参考答案

public class Worker {
    // 成员变量
    private String name;
    private int year;

    // 构造方法
    public Worker() {

    }
    public Worker(String name, int age) {
        this.name = name;
        this.year = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }
}

import java.util.Scanner;
public class Test01 {
    public static void main(String[] args) {
        // 创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入工人姓名：");
        String name = sc.nextLine();
        System.out.println("请输入工人工龄：");
        int year = sc.nextInt();
        // 创建对象
        Worker w = new Worker(name, year);
        // 输出信息
        System.out.println("该工人对象的信息如下：");
        System.out.println("姓名：" + w.getName());
        System.out.println("工龄：" + w.getYear());
    }
}

题目2（应用）

在登录注册页面中，除了用户名和密码外，通常也会包含验证码。验证码是用来区分用户是计算机还是人，防止恶意破解密码、刷票、灌水等行为。请查看Random、StringBuilder相关API，定义方法，获取一个包含4个字符的验证码，每一位字符是随机选择的字母和数字，可包含a-z,A-Z,0-9。例如：

import java.util.Random;
public class demo3 {
    public static void main(String[] args) {
        String code = getRandomCode();
        System.out.println("验证码为: " + code);
    }
    public static String getRandomCode() {
        //2.创建StringBuilder 对象 ,将可选择的字符都放入 StringBuilder对象中
        StringBuilder sb = new StringBuilder();
        //3.for循环  定义 a - z  利用StringBuilder#append 方法依次添加所有小写字母
        for (char i = 'a'; i <= 'z'; i++){
            //append 接收
            sb.append(i);}
        //4.for循环  定义A -Z, 利用append方法  一次添加大写字母
        for (char i = 'A'; i <= 'Z'; i++){
            sb.append(i);}
        //5. for 循环  0-9添加
        for (int i = 0; i <= 9; i++){
            sb.append(i);}
        //6.创建Random对象 用来保存验证码
        Random rm = new Random();
        String code = "";   //定义初始为空  用于接收验证码
        for (int i = 0; i < 4; i++) {
            //在循环中，使用Random的nextInt方法
            int index = rm.nextInt(sb.length()); 
            //使用StringBuilder的charAt方法，获取该索引上的字符，将其拼接到验证码字符串中。
            code += sb.charAt(index);
        }
        return code;
    }
}

7Kt5

训练目标

随机数类Random相关API、可变的字符序列StringBuilder相关API

训练提示

1、功能需要定义方法实现，方法的返回值是什么？需要参数列表吗？

2、先将可选择的字符都放到一个StringBuilder对象中。

3、怎样随机获取其中的四个字符呢？如果能随机获取一个，再获取四次，就可以了。那么怎样随机获取一个呢？我们知道，字符串中的字符是有索引的，如果可以随机获取到一个索引，就相当于随机获取到了该索引上的字符。

参考方案

训练步骤

1、定义方法，返回值是String，参数列表为空。

2、定义StringBuilder对象，将可选择的字符都放到StringBuilder对象中。

2.1、定义循环从a-z，使用StringBuilder的append方法依次添加所有小写字母

2.2、定义循环从A-Z，使用StringBuilder的append方法依次添加所有大写字母

2.3、定义循环从0-9，使用StringBuilder的append方法依次添加所有数字字符

3、创建Random对象。定义一个空字符串用于保存验证码。

4、定义一个执行4次的循环，用于获取4个字符。

4.1、在循环中，使用Random的nextInt方法，随机获取一个从索引0（包含）到字符串的长度（不包含）的索引。

4.2、使用StringBuilder的charAt方法，获取该索引上的字符，将其拼接到验证码字符串中。

5、返回结果，并在主方法中调用方法查看结果。

参考答案

import java.util.Random;

public class Test02 {
    public static void main(String[] args) {
        String code = getRandomCode();
        System.out.println(code);
    }
    public static String getRandomCode() {
        // 准备数据，将可选择的字符都放入StringBuilder中
        StringBuilder sb = new StringBuilder();
        for (char ch = 'a'; ch <= 'z'; ch++) {
            sb.append(ch);
        }
        for (char ch = 'A'; ch <= 'Z'; ch++) {
            sb.append(ch);
        }
        for (char ch = '0'; ch <= '9'; ch++) {
            sb.append(ch);
        }
        // 随机获取四位
        Random r = new Random();
        String code = "";
        for (int i = 0; i < 4; i++) {
            // 字符串中的字符有索引，随机获取一个索引即相当于随机获取到了该索引的字符
            int index = r.nextInt(sb.length()); // 从索引0（包含）到字符串的长度（不包含）
            code += sb.charAt(index); // 获取该索引上的字符
        }
        // 返回结果
        return code;
    }
}

题目3（应用）

在登录注册页面中，除了用户名和密码外，通常也会包含验证码。验证码是用来区分用户是计算机还是人，防止恶意破解密码、刷票、灌水等行为。在判断验证码时一般不区分大小写。请编写程序模拟验证码的判断过程，如果输入正确，给出提示，结束程序。如果输入错误，给出提示，验证码刷新，重新输入，直至正确为止。

生成4位随机验证码的功能在之前的题目中已经完成，可以直接使用。《定义方法，获取一个包含4个字符的验证码，每一位字符是随机选择的字母和数字，可包含a-z,A-Z,0-9。》

运行效果如下：

生成的验证码为：BkhD
请输入验证码
abcd
输入错误，请重新输入...
生成的验证码为：n1wX
请输入验证码
aaaa
输入错误，请重新输入...
生成的验证码为：Fm1a
请输入验证码
fm1a
输入正确

import java.util.Random;
import java.util.Scanner;

public class demo3 {
    public static void main(String[] args) {
        String code = getRandomCode();
        System.out.println("验证码为: " + code);
        System.out.println("请输入验证码");
        do {
            Scanner sc=new Scanner(System.in);
            String line=sc.nextLine();
            if(code.equalsIgnoreCase(line)){
                System.out.println("输入正确");
                break;
            }else {
                System.out.println("输入错误，请重新输入");
            }
        }while(true);
    }
    public static String getRandomCode() {      
        StringBuilder sb = new StringBuilder();  
        for (char i = 'a'; i <= 'z'; i++){
            sb.append(i);}        
        for (char i = 'A'; i <= 'Z'; i++){
            sb.append(i);} 
        for (int i = 0; i <= 9; i++){
            sb.append(i);}
        Random rm = new Random();
        String code = "";   //定义初始为空  用于接收验证码
        for (int i = 0; i < 4; i++) {

            int index = rm.nextInt(sb.length());

            code += sb.charAt(index);
        }
        return code;
    }}

训练目标

字符串的判断功能

训练提示

1、先定义获取验证码的方法，完成获取验证码的功能。

2、根据题目要求，判断需要一直到输入正确为止，所以需要使用循环。

3、用户输入由键盘录入，需要创建键盘录入对象。

4、判断是否正确需要将用户输入的字符串与生成的验证码比较，但不区分大小写，所以该使用哪个方法呢？

5、判断相等，给出提示，结束循环。判断不相等，给出提示，进入下一次循环。

参考方案

训练步骤

1、定义方法，实现获取包含4个字符的随机验证码。（参考以前的练习）

2、创建键盘录入Scanner对象。

3、定义while循环，循环条件为true。

4、在循环内，获取程序生成的验证码，提示用户输入，调用Scanner对象的nextLine方法获取用户输入。

5、使用String的equalsIgnoreCase方法比较生成的验证码和用户输入，因为不区分大小写。

5.1、如果相等，给出输入正确的提示，使用break语句跳出循环。

5.2、如果不相等，给出输入错误的提示，继续下一次循环。

参考答案

import java.util.Random;
import java.util.Scanner;

public class Test03 {
    public static void main(String[] args) {
        // 键盘录入对象
        Scanner sc = new Scanner(System.in);
        while (true) { // 不清楚输入多少次，定义死循环，输入正确时跳出即可。
            String code = getRandomCode();
            System.out.println("生成的验证码为：" + code);
            System.out.println("请输入验证码");
            String line = sc.nextLine();
            // 不区分大小写比较是否相等
            if (code.equalsIgnoreCase(line)) {
                System.out.println("输入正确");
                break; // 跳出循环，结束程序
            } else {
                System.out.println("输入错误，请重新输入...");
            }
        }
    }
    public static String getRandomCode() {
        // 准备数据
        StringBuilder sb = new StringBuilder();
        for (char ch = 'a'; ch <= 'z'; ch++) {
            sb.append(ch);
        }
        for (char ch = 'A'; ch <= 'Z'; ch++) {
            sb.append(ch);
        }
        for (char ch = '0'; ch <= '9'; ch++) {
            sb.append(ch);
        }
        // 随机获取四位
        Random r = new Random();
        String code = "";
        for (int i = 0; i < 4; i++) {
            // 字符串中的字符有索引，随机获取一个索引即相当于随机获取到了该索引的字符
            int index = r.nextInt(sb.length()); // 从索引0（包含）到字符串的长度（不包含）
            code += sb.charAt(index); // 获取该索引上的字符
        }
        // 返回结果
        return code;
    }
}

题目4（训练）

请编写程序，由键盘录入一个字符串，统计字符串中英文字母和数字分别有多少个。比如：Hello12345World中字母：10个，数字：5个。

import java.util.Scanner;

public class demo3 {
    public static void main(String[] args) {
        System.out.println("输入字符串");
        Scanner sc = new Scanner(System.in);
        String line =sc.nextLine();
        line= line.toLowerCase();
        int b=0;int c=0;
        for (int i=0;i<line.length();i++){
            char a =line.charAt(i);
            if(a>='a'&&a<='z'){
                b++;
            }else if (a<='9'&&a>='0'){
                c++;
            }
        }
        System.out.println("英文字母"+b);
        System.out.println("数字"+c);
    }
}

训练目标

字符串遍历

训练提示

1、键盘录入一个字符串，用 Scanner 实现 2、要统计两种类型的字符个数，需定义两个统计变量，初始值都为0 3、遍历字符串，得到每一个字符 4、判断该字符属于哪种类型，然后对应类型的统计变量+1，判断字母时需要考虑大小写，条件比较复杂，怎样做才能使判断更简单呢？

参考方案

为方便判断并统计，可将字符串中的字符都转为大写或者都转为小写。

训练步骤

1、创建键盘录入Scanner对象，使用nextLine方法接收输入的字符串。

2、为方便后续判断，使用String的toLowerCase方法，将字符串中的字符都转为小写。

3、需定义两个统计变量，初始值都为0

4、遍历字符串，得到每一个字符

5、判断该字符属于哪种类型，然后对应类型的统计变量+1，次数判断英文字母时只需判断小写即可。

参考答案

import java.util.Scanner;

public class Test07 {
    public static void main(String[] args) {
        //键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();
        // 为方便统计，将字符串中的字母都转为小写
        line = line.toLowerCase();
        //要统计两种类型的字符个数，需定义两个统计变量，初始值都为0
        int letterCount = 0;
        int numberCount = 0;
        // 遍历字符串，得到每一个字符
        for(int i=0; i<line.length(); i++) {
            char ch = line.charAt(i);
            // 判断该字符属于哪种类型，然后对应类型的统计变量+1
            if (ch >= 'a' && ch <= 'z') {
                letterCount++;
            } else if (ch >= '0' && ch <= '9') {
                numberCount++;
            }
        }
        //输出两种类型的字符个数
        System.out.println("英文字母：" + letterCount + "个");
        System.out.println("数字：" + numberCount + "个");
    }
}

题目5（应用）

请定义一个方法用于判断一个字符串是否是对称的字符串，并在主方法中测试方法。例如："abcba"、"上海自来水来自海上"均为对称字符串。

import java.util.Scanner;

public class demo3 {
    public static void main(String[] args) {
        System.out.println("输入字符串");
        Scanner sc = new Scanner(System.in);
        String line =sc.nextLine();
        boolean result=compareStr(line);
        System.out.println(result);
    }
    public static boolean compareStr(String line){
        StringBuilder sb=new StringBuilder(line);
        String reLine=sb.reverse().toString();
        if(line==null){
            return false;
        }
        boolean a=reLine.equals(line);
        return a;
    }
}

训练目标

字符串的反转功能，判断是否相等功能

训练提示

1、判断是否对称，方法的返回值是什么类型？参数列表是什么？

2、怎样判断对称呢？如果可以将字符串反转，反转后发现跟原来的字符串完全一样，不就可以判断出来了吗，那么哪个类有字符串的反转功能呢？

参考方案

训练步骤

1、定义方法，返回值类型为boolean，参数列表为String类型的一个参数。

2、将字符串转换为StringBuilder类型，调用StringBuilder的reverse()方法将字符串反转。

3、将反转后的字符串再转回String类型，并与原字符串比较，如果相等，返回true，否则返回false

4、在主方法中，定义一个字符串，调用方法测试结果。

参考答案

public class Test05 {
    public static void main(String[] args) {
        String str = "上海自来水来自海上";
        System.out.println(isSym(str));
    }

    public static boolean isSym(String str) {
        // 为了程序的健壮，如果传递的是空值，返回false
        if (str == null) {
            return false;
        }
        // 转换为StringBuilder
        StringBuilder sb = new StringBuilder(str);
        // 反转，再转成String
        String reStr = sb.reverse().toString();
        // 比较与原字符串是否相等
        // 相等返回true，不相等返回false，正好与equals的返回值一致，直接返回即可。
        return reStr.equals(str);
    }
}

题目6（应用）

我国的居民身份证号码，由由十七位数字本体码和一位数字校验码组成。请定义方法判断用户输入的身份证号码是否合法，并在主方法中调用方法测试结果。规则为：号码为18位，不能以数字0开头，前17位只可以是数字，最后一位可以是数字或者大写字母X。

训练目标

字符串的遍历、判断

训练提示

1、要判断字符串是否符合规则，方法的返回值类型是什么？参数列表是什么？

2、使用String的API，对每种不符合条件的情况作出判断，一旦发现不符合条件就可以结束方法的执行，返回结果了。

3、在主方法中创建键盘录入，调用方法，输入各种数据测试结果。

参考方案

针对每种不符合条件的情况作出判断

训练步骤

1、定义方法，返回值类型为boolean表示是否合法，参数列表为String类型的id，表示要判断的数据。

2、对每种不符合条件的情况作出判断

2.1、如果字符串长度不是18，返回false。

2.2、如果字符串以数字"0"开头，返回false。

2.3、遍历字符串，获取每一位字符，判断前17位，如果不是数字，返回false，判断最后一位如果不是数字或者X，返回false

2.4、所以的不符合条件都筛选完成，返回true

3、在主方法中创建键盘录入Scanner对象，调用nextLine()方法，获取用户输入，调用方法，传递参数，查看结果。要多运行几次，判断各种不符合条件的数据。

参考答案

import java.util.Scanner;
public class Test06 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入身份证号：");
        String id = sc.nextLine();
        System.out.println(check(id));
    }

    // 返回值boolean类型，表示是否符合规则。参数列表：需要判断的字符串
    public static boolean check(String id) {
        // 如果传递了空参数，返回false
        if (id == null) {
            return false;
        }
        // 如果是数字0开头，返回false
        if (id.startsWith("0")) {
            return false;
        }
        // 如果不是18位，返回false
        if (id.length() != 18) {
            return false;
        }
        // 遍历判断每一位
        for (int i = 0; i < id.length(); i++) {
            char ch = id.charAt(i);
            // 前17位都是数字,最后一位可以是数字或者大写字母X
            if (i == id.length() - 1) { // 最后一位
                if (ch < '0' || ch > '9' && ch != 'X') { // 不是数字或者X
                    return false;
                }
            } else { // 其他位
                if (ch < '0' || ch > '9') { // 不是数字
                    return false;
                }
            }
        }
        // 所有的规则都符合，返回true
        return true;
    }
}

题目7（练习）

定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，并在控制台输出结果。

要求：

1、如果传递的参数为空，返回null

2、如果传递的数组元素个数为0，返回[]

3、如果数组为int[] arr = {1,2,3}; ，执行方法后的输出结果为：[1, 2, 3]

训练目标

字符串的拼接

训练提示

1、定义方法的返回值是什么？参数列表是什么？

2、如果不做判断就对数组进行遍历，那么如果数组对象为空，会报出异常，怎样避免空指针异常呢？

3、拼接字符串必然涉及到频繁改变，该采用可变的字符序列StringBuilder比较好

4、遍历数组，按照题目格式拼接数组中的元素。

5、将字符串返回

6、在主方法中定义数组，并调用方法，打印结果

参考方案

使用StringBuilder拼接字符串

训练步骤

1、定义方法返回值类型：String，参数：int[] arr

2、判断对象如果为null，直接返回null

3、创建StringBuilder对象

4、遍历数组，按照要求进行拼接数组元素，如果是不是最后一个元素，还要拼接逗号和空格

5、将StringBuilder转为String返回

6、在主方法中定义数组，并调用方法，打印结果

参考答案

public class Test07 {
    public static void main(String[] args) {
        // 定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
        int[] arr = {1, 2, 3};
        // 调用方法，输出结果
        System.out.println(arrayToString(arr));
    }

    /*定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回
		返回值类型：String
		参数：int[] arr
     */
    public static String arrayToString(int[] arr) {
        // 健壮性判断
        if (arr == null) {
            return null;
        }
        //在方法中用 StringBuilder 按照要求进行拼接，并把结果转成 String 返回
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            // 拼接元素
            sb.append(arr[i]);
            // 如果不是最后一个元素，再拼接逗号和空格
            if (i != arr.length - 1) {
                sb.append(", ");
            }
        }
        sb.append("]");
        return sb.toString();
    }
}

题目8（扩展）

在String类的API中，有如下两个方法：

// 查找参数字符串str在调用方法的字符串中第一次出现的索引，如果不存在，返回-1
public int indexOf(String str)

// 截取字符串，从索引beginIndex（包含）开始到字符串的结尾
public String substring(int beginIndex)

请仔细阅读API中这两个方法的解释，完成如下需求。

现有如下文本："Java语言是面向对象的，Java语言是健壮的，Java语言是安全的，Java是高性能的，Java语言是跨平台的"。请编写程序，统计该文本中"Java"一词出现的次数。

训练目标

String类API的灵活使用

训练提示

1、要找的子串是否存在，如果存在获取其出现的位置。这个可以使用indexOf完成。 2、如果找到了，那么就记录出现的位置并在剩余的字符串中继续查找该子串，而剩余字符串的起始位是出现位置再加上子串的长度。

3、以此类推，通过循环完成查找，如果找不到就是-1，每次找到用计数器记录次数。

参考方案

从左至右依次查找，将已查找的部分截取掉。

训练步骤

1、定义方法，返回值int表示次数，参数列表两个字符串，第一个表示在哪个字符串中查找，第二个表示要查找的目标子串

2、定义统计变量表示次数。

3、定义索引变量，表示每次找到子串出现的索引。

4、定义循环，判断条件为在字符串中找到了目标子串，使用indexOf实现。

5、如果找到的索引不是-1，在循环中，统计变量累加。

6、把查找过的部分剪切掉，从找到的索引+子串长度的位置开始截取，使用substring实现。

7、将次数返回

8、在主方法中，定义字符串表示题目中的文本，定义字符串表示要查找的子串，调用方法，获取结果。

参考答案

public class Test08 {
    public static void main(String[] args) {
        String str = "Java语言是面向对象的，Java语言是健壮的，Java语言是安全的，Java是高性能的，Java语言是跨平台的";
        String tar = "Java";
        // 调用方法并输出
        System.out.println(search(str, tar));

    }
    // 返回值int表示次数，参数列表str表示在哪个字符串中查找，tar表示要查找的目标子串
    public static int search(String str, String tar) {
        // 定义统计变量表示次数
        int count = 0;
        // 定义索引变量，表示每次找到子串出现的索引
        int index = -1;
        // 定义循环，判断条件为在字符串中找到了目标子串
        while ((index = str.indexOf(tar)) != -1) { // 将找到的索引赋值给变量并判断
            // 次数累加
            count++;
            // 把查找过的部分剪切掉，从找到的索引+子串长度的位置开始截取。
            str = str.substring(index + tar.length());
        }
        return count;
    }
}

###