java基础应用题

香香不学习

已于 2023-04-27 17:52:36 修改

阅读量260

点赞数 1

文章标签： java jvm linux

于 2023-04-20 15:24:19 首次发布

本文链接：https://blog.csdn.net/firenaimal/article/details/130267677

版权

第一天

一、每日一考

JDK，JRE，JVM三者之间的关系

Jdk中包含jre，jre中包含jvm

为什么要配置环境变量，如何配置

配置环境变量，可以让你在任何地址使用jdk，不会固定在jdk的下载地址
在环境配置中添加JAVA_HOME，添加jdk的下载地址，在Path中添加一个jdk的地址到\bin路径下

常用的命令行有哪些(至少写出4个)

dir 列出文件下目录和文件夹
cd 跳转到想去的地址
md 创建目录
rd 删除目录
cd… 返回上一级目录
cd\ 返回根目录
del 删除文件夹
exit 退出

请描述基于记事本编写程序的步骤

创建一个文件，后缀是.java，文件名需要和类名相同（如果没有public，文件名和类名可以不同，但是编译生成的名与类名相同），写好一个java代码，在文件夹地址下输入cmd进入DOS命令窗使用javac对文件进行编译（需要带后缀.java），再使用java进行运行

答案 1. 将 Java 代码编写到扩展名为 .java 的文件中。
2. 通过 javac 命令对该 java 文件进行编译。
3. 通过 java 命令对生成的 class 文件进行运行。
5. 请描述程序的执行过程写好一个java代码，在文件夹地址下输入cmd进入DOS命令窗口，使用javac对文件进行编译（需要带后缀.java），再使用java进行运行

请描述你理解的注释

注释是不进行代码运行的部分，//单行注释，/* /多行注释 /* * /文本注释，增加代码的可读性

请描述你理解的标识符

可以自己命名的地方为标识符答案在Java中，凡是自己可以起名字的地方，都称之为标识符。比如：对类名、变量名、方法名、参数名等的修饰。
标识符的命名规则由26个英文字母大小写，0-9 ，_或 $ 组成数字不可以开头。不可以使用关键字和保留字，但能包含关键字和保留字。
Java中严格区分大小写，长度无限制。标识符不能包含空格。

请描述你理解的变量

变量是定义一个变量名a，a中的值是可变的定义变量为在内存中开辟空间为变量赋值为在空间中赋值变量必须需要数据类型来定义

请描述常用的数据类型有哪些

四类八种，整数类型（byte short int long）字符类型（char）布尔类型Boolean（false true）
浮点类型（float double）扩展引用数据类型数组类接口

请描述int类型做"/"运算时有哪些注意事项

Int为整数类型,做除结果也必须是整数类型

请描述"%"做取余运算时有哪些注意事情

使用%做取余运算是，被除数和除数的类型，影响着结果的类型，如果被除数和除数任何一项是浮点类型，其结果必须是小数点

请描述"++"的作用及前置++和后置++的区别

前置++是在代码运行之前运行的，优先级比较高，参与之后的运算；后置++是在代码运行之后运行的，不参与之后的运算

第二天

一、每日一考
1.请描述标识符的命名规则

由26个英文字母大小写，0-9 ，_或 $ 组成数字不可以开头。不可以使用关键字和保留字，但能包含关键字和保留字。
Java中严格区分大小写，长度无限制。标识符不能包含空格

请描述数据类型存在的意义

1.数据类型解决了“存”的问题：它决定了使用这个类型需要开辟空间的大小以及内存中的数据是如何存储的；
2.数据类型解决了“取（读）”的问题：它改变了看待内存空间的视角，比如在内存中同样的两块4个字节的空间，存放着同样的二进制码，如果这两块内存对应的两个变量类型不一样，那么它们的意义也就不一样了。

请描述在使用变量时的注意事项

在Java中，利用声明的方式将某个数据保存下来供程序使用，并且这个数据是可以根据自己需求发生改变的。第一步：声明变量
声明变量的语法格式：数据类型变量名称; 比如：int a; 第二步：赋值注意事项：
1.在Java中，赋值使用等号完成，并且将等号右侧的值赋给等号左侧的变量名称。
2.赋值语法格式：变量名称 = 值;
3.比如：a = 18; 通常使用“声明的同时并赋值”的这种方式。结论变量的声明和赋值可分开进行变量声明的同时也可赋值英文""的作用是原样输出
+是连接符()，用于变量的连接

请描述/n、/t的作用

1：\n:标识换行 2：\t:标识空四个字符，想当于缩进，Tab键

请描述赋值运算符+=和=的区别

1）=：a=1即为变量a赋值1 2）+=：a+=1相当于a=a+1

6.请描述三目运算符的使用场景

当是二选一时，则就可以直接使用三目运算符

7.请描述实现从键盘输入的步骤

第一步：导入包，必须位于当前Java源文件所有类的最前面 import java.util.Scanner; 还可以编写为import
java.util.*; 注意：在一个Java源文件中只需要编写一次导入包

第二步：创建Scanner对象 Scanner input = new Scanner(System.in);
注意：一个方法中只需要编写一次创建Scanner对象第三步：友好提示(可有可无，但是建议编写上)
System.out.print(“请输入：”); 第四步：接收键盘输入 int a = input.nextInt();
//注意：当按回车键，则表示键盘输入完毕，并且将输入的值赋给左侧的变量名称a double d = input.nextDouble();
String a = input.next();
//注意：在Java中，键盘接收字符串类型时，没有nextString()，而是编写为next()

第三天

一、每日一考

请描述你理解的循环

在java中,按照一定的次数重复的去执行程序，直至到达次数上限，将重复的代码编写一遍，然后重复调用执行即可，这样的程序结构就是循环。
重复的代码，重复编写，导致代码冗长，观看性不强。可以输入一个直角三角形或者九九乘法表的时候时候。

请描述嵌套for循环执行的过程

初始化部分：完成变量的初始值，例如： int=1；
循环条件部分（布尔表达式）：完成循环条件判断，如果条件为true，则执行循环，否则结束当前整个for循环
循环体部分：也就是：将重复的代码编写在循环体中，并且重复的代码只写一遍，例如：System.out.println(“hello world”);
迭代部分（更新）：完成变量值的改变，例如i++；

请描述你理解的数据类型

数据类型一般指数据元。数据元也称为数据元素，是用一组属性描述其定义、标识、表示和允许值的数据单元，在一定语境下，通常用于构建一个语义正确、独立且无歧义的特定概念语义的信息单元

请描述你理解的数据类型的转换

在八种基本数据类型中，除了boolean外，其他几种数据类型都可以进行转化，取值范围小的转取值范围大的可以直接转换，也叫做隐式转换，哪取值范围大的怎么转换取值的范围小的，就需要显式转换（也叫强制转换），但是会造成精度丢失，而且不会进行四舍五入。
基本数据类型中除了boolean数据类型以外，剩余7种数据类型之间是可以相互转换的。
当对byte、short、char类型赋值时，如果没有超出当前数据类型取值范围，则是可以直接赋值的。

请简述你对程序流程控制结构的理解

依据需求的不同会产生不同的程序结构，从而导致程序的执行流程是也不同的。我们把这一现象称之为程序的流程控制结构。顺序结构选择结构循环结构
思维导图上整理

请简述选择结构的分类及每一种分类的使用场景

If单选择结构：在二选一的时候，if语句对条件表达式进行一次测试，若测试为真，则执行下面的语句，否则跳过该语句。
If双选择结构：同样是二选一的时候，当条件表达式为真时，执行语句块1，否则，执行语句块2。也就是else部分。根据条件的成立与否进行2选1。
If多选择结构：多选择结构是根据多个条件的成立与否进行结果的选择，就是说这种结构可以检测到多种可能的情况。  If嵌套结构：像if
语句一样嵌套 else if…else，也就是说你可以在另一个 if 或者 else if 语句中使用 if 或者 else if
语句。有时候在解决某些问题的时候，需要缩小查找范围，需要有层级条件判断，提高效率

看图说话

在这里插入图片描述

1）无结果

在这里插入图片描述

2） b

在这里插入图片描述

第四天

一、每日一考

请描述你理解的循环

事件重复的执行，代码重复，可以应用循环减少代码冗余，方便观看

请描述嵌套for循环执行的过程
请描述你理解的数据类型

基本数据类型：四类八种整数类型:byte short int long 浮点类型：floa double
布尔类型：boolean（false ；true）字符类型：char 引用数据类型：数组，类，接口
数据类型分多种的区别在于，存储的大小，小的数据不必用太大的数据类型存放。

请描述你理解的数据类型的转换

在这里插入图片描述

数据类型的转换分隐式和显式
隐式转换：取值范围小的数据类型是可以直接给取值范围大的数据类型赋值，构成也叫做隐式类型转换

显式转换：取值范围大的类型是不能直接给取值范围小的赋值，则必须要进行，强制类型转换(显式类型转换)，可能会存在精度有丢失，但是不会进行四舍五入

在这里插入图片描述

判断（b，c，d，e）

参数列表：参数的个数不同，参数的数据类型不同，参数类型的顺序不同。方法重载的特点：

要求方法名称必须相同
参数；列表至少有一要素不同参数个数参数类型参数类型顺序

和返回值类型无关
5、哪个选项和show()方法重载

class Demo{
    void show(int a,int b,float c){（ACD）}
}

A.void show(int a,float c,int b){}//yes

B,void show(int a,int b,float c){}//一模一样。不可以出现在同一个类中。

C.int show(int a,float c,int b){return a;}//yes。

D.int show(int a,float c){return a;}//yes

6、方法重载(overload)必须满足__BCF______
A. 在不同class中定义的方法 B.在同一类型中定义的方法
C. 方法名必须相同 D.返回类型必须相同
E. 参数一定不同 F.参数可以相同

答案：

7、写出输出结果

class Demo{
public static void main(String[] args){
int x = 1;
for(show('a'); show('b') && x<3; show('c')){
show('d'); 
x++;
}
}
public static boolean show(char ch){
System.out.print(ch);
return true;
}
}

//答案：abdcbdcb

第五天

1、请简述你对封装的理解？

封装就是隐藏类的内部信息(属性和方法)，不允许外部程序直接访问，而是通过公有的方法才能完成访问(赋值方法get()和取值方法set())

2、请简述你对构造方法的理解？

构造方法的名字与类的名字一致，它不声明返回值类型。（与声明为void不同），不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值

3、请简述你对构造方法重载的理解？

在同一个类中至少出现2个或者2个以上的参数列表必须不同的构造方法，这里的参数列表包括参数的个数、参数类型、参数类型顺序三要素，三要素若仅有一要素不同，那么就构成方法的重载。

4、请谈谈你对this关键字的理解

this在Java中代表的是当前对象，也就是说：当前谁调用这个方法则这个对象就是谁
this关键字可以访问本类中的实例变量、实例方法以及本类中的构造方法

5、请谈谈你对static关键字的理解

用static定义的变量或方法，是由该类所有示例共享的

6、什么是局部变量和全局变量?

局部变量定义在方法中只能作用在方法体内，全局变量定义在全局中作用在整个类中

7、下列关于变量的叙述哪个是错的（ c）
A、实例变量是类的成员变量
B、在方法中定义的局部变量在该方法执行时被创建
C、实例变量用关键字static声明
D、局部变量在使用前必须进行初始化

8、阅读程序给出答案

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){
		this();
		System.out.println("AB");
	}
}
class B{
	public B(){
		System.out.println("B");
	}
}

答案：
BAAB

第六天

【练习题】01.类的成员变量

请定义一个交通工具(Vehicle)的类，其中有: 属性：速度(speed)，体积(size)等等方法：移动(move(int
s))，设置速度(setSpeed(int speed))，加速speedUp(),减速speedDown()等等.
最后在测试类Vehicle中的main()中实例化一个交通工具对象，并通过方法给它初始化speed,size的值，并且通过打印出来。另外，调用加速，减速的方法对速度进行改变。调用
move方法输出移动距离。

package javaDay05_fengzhuan.hw_01.hw;

public class Vehicle {
    /**
     * 请定义一个交通工具(Vehicle)的类，其中有:
     * 属性：速度(speed)，体积(size)等等
     * 方法：移动(move(int s))，设置速度(setSpeed(int speed))，加速speedUp(),减速speedDown()等等.
     * 最后在测试类Vehicle中的main()中实例化一个交通工具对象，并通过方法给它初始化speed,size的值，
     * 并且通过打印出来。另外，调用加速，减速的方法对速度进行改变。调用 move方法输出移动距离。
     */
    int speed;
    double size;

    public  void move(int s){//时间
        System.out.println("行驶速度为:"+speed+"时间："+s+"h,一共行驶了"+speed * s+"米");
    }
    public  void speedUp(int a){
        System.out.println("加速");
        this.speed=speed+a;
        if(speed>0&&speed<320){
            System.out.println("加速后，现在车速为："+speed);
        }else {
            System.out.println("超过320km/h起飞");
        }

    }public  void speedDown(int a){
        System.out.println("减速");
        this.speed=speed-a;
        if(speed>0){

            System.out.println("减速后，现在车速为："+speed);
        }else {
            System.out.println("速度为0停车");
        }

    }

    public Vehicle() {
    }

    public Vehicle(int speed, double size) {
        this.speed = speed;
        this.size = size;
        System.out.println("开始速度"+speed+"km/h，长度"+size+"米");
    }

    public int getSpeed() {
        return speed;
    }

    public void setSpeed(int speed) {
        this.speed = speed;
    }

    public double getSize() {
        return size;
    }

    public void setSize(double size) {
        this.size = size;
    }

    @Override
    public String toString() {
        return "Vehicle{" +
                "speed=" + speed +
                ", size=" + size +
                '}';
    }
}

最后在测试类Vehicle中的main()中实例化一个交通工具对象，并通过方法给它初始化speed,size的值，
并且通过打印出来。另外，调用加速，减速的方法对速度进行改变。调用 move方法输出移动距离。

package javaDay05_fengzhuan.hw_01.hw;

public class text {
    public static void main(String[] args) {
        //速度(speed)，体积(size)
        Vehicle vehicle =new Vehicle(100,3.4);
        vehicle.move(1);
        vehicle.speedUp(306);
        vehicle.speedDown(457);
    }
}

【练习题】02.构造方法

编写Java程序，用于显示人的姓名和年龄。
定义一个人类（Person），该类中应该有两个私有属性，姓名（name）和年龄（age）。定义构造方法，用来初始化数据成员。再定义显示（display）方法，将姓名和年龄打印出来。
在main方法中创建人类的实例，然后将信息显示。

package javaDay05_fengzhuan.hw_02;

/**
 * 编写Java程序，用于显示人的姓名和年龄。
 * 定义一个人类（Person），该类中应该有两个私有属性，姓名（name）和年龄（age）。
 * 定义构造方法，用来初始化数据成员。再定义显示（display）方法，将姓名和年龄打印出来。
 * 在main方法中创建人类的实例，然后将信息显示。
 */
public class Person {
    private String name;
    private int age;

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

    public String display() {
        return "person{" +
                "name='" + this.name + '\'' +
                ", age=" + this.age +
                '}';
    }

    public static void main(String[] args) {
        Person person =new Person("战三",19);
        String sta = person.display();
        System.out.println(sta);
     }
}

【练习题】03.get方法和set方法

定义一个类，该类有一个私有成员变量，通过构造方法将其进行赋初值，并提供该成员的getXXX()和setXXX()方法
提示：假设有private String name;则有 public void setName(String name){
this.name = name; } public String getName(){ return this.name; }

package javaDay05_fengzhuan.hw_03;

public class Studednt {
    /**
     * 定义一个类，该类有一个私有成员变量，通过构造方法将其进行赋初值，并提供该成员的getXXX()和setXXX()方法
     * 提示：假设有private String name;则有
     * public void setName(String name){
     * this.name = name;
     * }
     * public String getName(){
     * return this.name;
     * }
     */
    private String name;

    public String getName() {
        return this.name;
    }

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

package javaDay05_fengzhuan.hw_03;

public class text {
    public static void main(String[] args) {
        Studednt stu =new Studednt();
        stu.setName("长伞");

        System.out.println(stu.getName());
    }
}

【练习题】04.构造方法与重载

为“无名的粉”写一个类：class WuMingFen 要求：
1.有三个属性：面码:String theMa 粉的份量(两)：int quantity 是否带汤：boolean likeSoup
2.写一个构造方法，以便于简化初始化过程，如： WuMingFen f1 = new WuMingFen(“牛肉”,3,true);
3.重载构造方法，使得初始化过程可以多样化： WuMingFen f2 = new WuMingFen(“牛肉”,2);
4.如何使得下列语句构造出来的粉对象是酸辣面码、2两、带汤的？ WuMingFen f3 = new WuMingFen();
5. 写一个普通方法：check()，用于查看粉是否符合要求。即：将对象的三个属性打印在控制台上。

package javaDay05_fengzhuan.hw_04;

public class WuMingFen {
    /**
     *
     * 2.写一个构造方法，以便于简化初始化过程，如：
     * WuMingFen f1 = new WuMingFen("牛肉",3,true);
     * 3.重载构造方法，使得初始化过程可以多样化：
     * WuMingFen f2 = new WuMingFen("牛肉",2);
     * 4.如何使得下列语句构造出来的粉对象是酸辣面码、2两、带汤的？
     * WuMingFen f3 = new WuMingFen();
     * 5.	写一个普通方法：check()，用于查看粉是否符合要求。即：将对象的三个属性打印在控制台上。
     */
    String theMa;
    int quantity;
    boolean likeSoup;

    /**
     *
     * 有三个属性：面码:String theMa 粉的份量(两)：int quantity
     *      * 是否带汤：boolean likeSoup
     */
    public WuMingFen(String theMa,int quantity,boolean likeSoup){
        this.theMa =theMa;
        this.quantity=quantity;
        this.likeSoup=likeSoup;
    }

    @Override
    public String toString() {
        return "WuMingFen{" +
                "theMa='" + theMa + '\'' +
                ", quantity=" + quantity +
                ", likeSoup=" + likeSoup +
                '}';
    }
    /**
     * 写一个普通方法：check()，用于查看粉是否符合要求。即：将对象的三个属性打印在控制台上。
     */
    public String chevk(){
       /*if(likeSoup){
            return "带汤的";//return有结束方法的作用
        }*/
        return this.theMa+"   "+ this.quantity +"两   " +this.likeSoup;
    }
}

package javaDay05_fengzhuan.hw_04;

public class text {
    public static void main(String[] args) {
        WuMingFen f1 =new WuMingFen("牛肉",3,true);
        WuMingFen f2 = new WuMingFen("牛肉",2,true);
        System.out.println(f1);
        System.out.println(f2);
        /** 4.如何使得下列语句构造出来的粉对象是酸辣面码、2两、带汤的？
            * WuMingFen f3 = new WuMingFen();
            * 5.写一个普通方法：check()，用于查看粉是否符合要求。即：将对象的三个属性打印在控制台上
         */
        WuMingFen f3 = new WuMingFen("酸辣粉",2,true);
        String wa=f3.chevk();
        System.out.println(wa);
    }
}

【练习题】05.构造方法与重载

定义一个牛肉面的类(Noodle),它的属性有，牛肉面宽度 width 尺寸：size (大碗还是小碗) 大碗8元，小碗6元
是否加肉：beef :加肉+4元加蛋的数量：eggs :每个1元；定义构造方法来根据不同的条件创建不同的牛肉面 Noodle(){
//不加肉，大碗，不加蛋，中宽； } Noodle(String width,int size) Noodle(String
width,int size,boolean beef); Noodle(String width,int size,boolean
beef,int eggs); 再定义一个方法，用来显示当前牛肉面的信息，并显示金额； void showNoodleInfo();

package javaDay05_fengzhuan.hw_05;

public class Noodle {
    /**
     * 尺寸：size  (大碗还是小碗) 大碗8元，小碗6元
     * 是否加肉：beef   :加肉+4元
     * 加蛋的数量：eggs  :每个1元；
     * 定义构造方法来根据不同的条件创建不同的牛肉面
     * Noodle(){
     *   //不加肉，大碗，不加蛋，中宽；
     * }
     * Noodle(String width,int size)
     * Noodle(String width,int size,boolean beef);
     * Noodle(String width,int size,boolean beef,int eggs);
     * 再定义一个方法，用来显示当前牛肉面的信息，并显示金额；
     * void  showNoodleInfo();
     */
    String width;
    String size;
    boolean beef;
    int eggs;
    Noodle(String width,String size,boolean beef,int eggs){//不加肉，大碗，不加蛋，中宽；
        this.width=width;
        this.size=size;
        this.beef=beef;
        this.eggs=eggs;


      }

    @Override
    public String toString() {
        return "Noodle{" +
                "width='" + width + '\'' +
                ", size='" + size + '\'' +
                ", beef=" + beef +
                ", age=" + eggs +
                '}';
    }

    int showNoodleInfo(){
        int  price = 0;
        if(size.equals("大碗")){
             price =8;
            System.out.println("大碗");
        }else if(size.equals("中碗")){
             price =7;
            System.out.println("中碗");
        }else if(size.equals("小碗")){
             price =6;
            System.out.println("小碗");
        }else {
            System.out.println("没有");
        }
        if(beef){
            System.out.println("加肉");
            price +=4;

        }
        price += eggs;
        System.out.println("加鸡蛋"+eggs);
        System.out.println(price);
        return price;
    }
}

package javaDay05_fengzhuan.hw_05;

public class text {
    public static void main(String[] args) {
        //不加肉，大碗，不加蛋，中宽；
        //String width,String size,boolean beef,boolean age
        Noodle noodle = new Noodle("中宽","中碗",true,10);
        System.out.println(noodle);
        noodle.showNoodleInfo();

    }
}

【练习题】06.构造方法与重载

建立一个汽车类，包括轮胎个数，汽车颜色，车身重量等属性。并通过不同的构造方法创建事例。至少要求：汽车能够加速，减速，停车。
要求：命名规范，代码体现层次，有友好的操作提示。

package javaDay05_fengzhuan.hw_06;

public class Car {
    /**
     * 建立一个汽车类，包括轮胎个数，汽车颜色，车身重量等属性。并通过不同的构造方法创建事例。
     * 至少要求：汽车能够加速，减速，停车。
     * 要求：命名规范，代码体现层次，有友好的操作提示。
     */
    private int number;
    private String color;
    private int weight;
    int speed;
    public  Car(int number){
        this.number=number;

    }
    public  Car(int number ,String  color){
        this.number=number;
        this.color=color;
    }
    public  Car(int number,String color,int weight){
        this.number=number;
        this.color=color;
        this.weight=weight;
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public String getColor() {
        return color;
    }

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

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }

    @Override
    public String toString() {
        return "Car{" +
                "number=" + number +
                ", color='" + color + '\'' +
                ", weight=" + weight +
                '}';
    }

    public int speedUp(int b){
        this.speed=speed+b;
        return  speed;
    }
    public int speedDown(int a){
        this.speed =speed-a;
        System.out.println();
        return  speed;
    }
    public void stop(){
        System.out.println("停车");
    }

}

package javaDay05_fengzhuan.hw_06;

public class text {
    public static void main(String[] args) {
        //包括轮胎个数，汽车颜色，车身重量等属性
        Car car = new Car(4);
        Car car2 = new Car(4,"红色");
        Car car3 = new Car(4,"黑色",4);
        car.speed=30;
        int up= car.speedUp(4);
        System.out.println(up);
        car2.setColor("绿色");
        System.out.println(car2.getColor());

    }
}

【练习题】07.构造方法与重载

创建一个类，为该类定义三个构造函数，分别执行下列操作： 1、传递两个整数值并输出其中较大的一个值
2、传递三个double值并计算出其乘积，将结果输出 3、传递两个字符串值并将它们连接到一起后输出 4、在main方法中测试构造函数的调用

package javaDay05_fengzhuan.hw_07;

public class Max {
    /**
     * 创建一个类，为该类定义三个构造函数，分别执行下列操作：
     * 1、传递两个整数值并输出其中较大的一个值
     * 2、传递三个double值并计算出其乘积，将结果输出
     * 3、传递两个字符串值并将它们连接到一起后输出
     * 4、在main方法中测试构造函数的调用
     */
    String a;
    String b;
    double s;
    double u;
    double m;
    public Max(double s,double u){
        System.out.println(s>u?s:u);
    }
    public  Max(double s,double u,double m){
        System.out.println("三数之积"+s*u*m);
    }
    public Max(String a,String b){
        System.out.println(a+"-"+b);

    }

}

package javaDay05_fengzhuan.hw_07;

public class text {
    /**
     * 传递两个整数值并输出其中较大的一个值
     *      * 2、传递三个double值并计算出其乘积，将结果输出
     *      * 3、传递两个字符串值并将它们连接到一起后输出
     */
    public static void main(String[] args) {
        Max max =new Max(1.9,3.9);
        Max max1 =new Max(22,24,34);
        Max max2 =new Max("ssd","ddsd");

    }
}

【练习题】08.类的综合练习

1、写一个名为Account的类模拟账户。该类的属性和方法如下图所示。该类包括的属性：账号id，余额balance，年利率annualInterestRate；包含的方法：访问器方法（getter和setter方法），取款方法withdraw()，存款方法deposit()。

//部分代码提示
Account
private int id
private double balance
private double annualInterestRate
public Account (int id, double balance, double annualInterestRate )
public int getId()
public double getBalance()
public double getAnnualInterestRate()
public void setId( int id)
public void setBalance(double balance)
public void setAnnualInterestRate(double annualInterestRate)
public void withdraw (double amount)
public void deposit (double amount)

package javaDay05_fengzhuan.hw_08_01;

public class Account {
    private int id;
    private double balance;
    private double annualInterestRate;

    public Account(int id, double balance, double annualInterestRate) {
        this.id = id;
        this.balance = balance;
        this.annualInterestRate = annualInterestRate;
    }

    public Account() {
    }

    public int getId() {
        return id;
    }

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

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    public double getAnnualInterestRate() {
        return annualInterestRate;
    }

    public void setAnnualInterestRate(double annualInterestRate) {
        this.annualInterestRate = annualInterestRate;
    }
    //取款方法withdraw()，存款方法deposit()
    public void withdraw (double amount){
        System.out.println("=====取款页面=====");
        System.out.println("存款"+balance);
        if(amount<=balance){
            this.balance= balance-amount;
            System.out.println("取出"+amount);
            System.out.println("最新的余额"+balance);
        }else {
            System.out.println("余额不足");
        }

    }
    public void deposit (double amount){
        System.out.println("=====存款页面=====");
        System.out.println("存款"+balance);
        this.balance =balance+amount;

        System.out.println("存入"+amount);
        System.out.println("最新的余额"+balance);
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", balance=" + balance +
                ", annualInterestRate=" + annualInterestRate +
                '}';
    }
}

提示：在提款方法withdraw中，需要判断用户余额是否能够满足提款数额的要求，如果不能，应给出提示。
2. 创建Customer类。

Customer
private String firstName
private String lastName
private Account account
public Customer(String f,String l)
public String getFirstName()
public String getLastName()
public Account getAccount()
public void setAccount(Account account)

package javaDay05_fengzhuan.hw_08_01;

public class Customer {
    private String firstName;
    private String lastName;
    private Account account;//引用

    public Customer() {
    }

    public Customer(String firstName, String lastName, Account account) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.account = account;
    }

    public Customer(String f,String l){
        this.firstName = f;
        this.lastName = l;
    }
    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;

    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public Account getAccount() {
        return account;
    }

    public void setAccount(Account account) {
        this.account = account;
        System.out.println("=====用户个人信息=====");
        System.out.println("用户"+firstName);
        System.out.println("账号为"+ account.getId());
        System.out.println("银行余额"+ account.getBalance());
        System.out.println("利率"+ account.getAnnualInterestRate());

    }

    @Override
    public String toString() {
        return "Customer{" +
                "firstName='" + firstName + '\'' +
                ", lastName='" + lastName + '\'' +
                ", account=" + account +
                '}';
    }
}

a. 声明三个私有对象属性：firstName、lastName和account。 b.
声明一个公有构造器，这个构造器带有两个代表对象属性的参数（f和l） c.
声明两个公有存取器来访问该对象属性，方法getFirstName和getLastName返回相应的属性。 d. 声明setAccount
方法来对account属性赋值。 e. 声明getAccount 方法以获取account属性。

3.写一个测试程序。
（

1）创建一个Customer ，名字叫 Jane Smith, 他有一个账号为1000，余额为2000元，年利率为 1.23％的账户。
（2）对Jane Smith操作。存入 100 元，再取出960元。再取出2000元。打印出Jane Smith 的基本信息

成功存入：100.0 成功取出：960.0 余额不足，取款失败 Customer [Smith, Jane] has a account:
id is 1000, annualInterestRate is 1.23％, balance is 1140.0

package javaDay05_fengzhuan.hw_08_01;

public class text {
    public static void main(String[] args) {
        Customer c1 =new Customer("Jane","Smith");
        //他有一个账号为1000，余额为2000元，年利率为 1.23％ 的账户
        Account account=new Account(1000,2000,0.0123);
        c1.getFirstName();
        c1.getLastName();
        c1.setAccount(account);
        System.out.println(c1);
        System.out.println(c1.getAccount());
        //取款方法withdraw()，存款方法deposit()
        account.withdraw(1000);
        account.deposit(2000);
        account.withdraw(10000);
    }
}

【练习题】09.static修饰符

创建一个名称为StaticDemo的类，并声明一个静态变量和一个普通变量。对变量分别赋予10和5的初始值。在main()方法中输出变量值。

package fengzhuang.StaticDemo_09;

public class StaticDemo {
    static int count=10;
    public int age=5;
}

package fengzhuang.StaticDemo_09;

public class StaticDemoTest {
    public static void main(String[] args) {
        StaticDemo staticDemo = new StaticDemo();
        System.out.println(StaticDemo.count);
        System.out.println(staticDemo.age);
    }
}

【练习题】10.static修饰符

使用static 修饰属性String name ，在主函数中声明多个对象，修改其中一个对象的name值，打印其它对象的name值

package javaDay05_fengzhuan.hw_10;

public class nameText {
    public static void main(String[] args) {
        Name name = new Name();
        Name name2 = new Name();
        Name name3 = new Name();
        Name name4 = new Name();
        /**
         * 修改其中一个对象的name值 ，打印其它对象的name值
         */
        name2.name="丽丝";
        System.out.println(name.name);

    }
}

package javaDay05_fengzhuan.hw_10;

public class Name {
    /**
     * 使用static 修饰属性String name ，
     * 在主函数中声明多个对象，修改其中一个对象的name值 ，打印其它对象的name值
     */
    static  String name="展示";


}

【练习题】11.static修饰符

调用使用static 修饰自定义方法，打印方法内容。

package javaDay05_fengzhuan.hw_11;

public class Sta {
    /**
     * 调用使用static 修饰自定义方法，打印方法内容
     * @return
     */
    public static int auount(int i){
         if(i>2){
             i+=2;
         }else{
             i++;
         }
        return i;
    }
}

package javaDay05_fengzhuan.hw_11;

public class text {
    public static void main(String[] args) {
        Sta sta= new Sta();
        Sta sta2= new Sta();

        System.out.println(sta.auount(4));
        System.out.println(sta2.auount(3));
        System.out.println(sta2.auount(1));
    }
}

香香不学习

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
java基础应用题

在八种基本数据类型中，除了boolean外，其他几种数据类型都可以进行转化，取值范围小的转取值范围大的可以直接转换，也叫做隐式转换，哪取值范围大的怎么转换取值的范围小的，就需要显式转换（也叫强制转换），但是会造成精度丢失，而且不会进行四舍五入。2.数据类型解决了“取（读）”的问题：它改变了看待内存空间的视角，比如在内存中同样的两块4个字节的空间，存放着同样的二进制码，如果这两块内存对应的两个变量类型不一样，那么它们的意义也就不一样了。依据需求的不同会产生不同的程序结构，从而导致程序的执行流程是也不同的。
复制链接

扫一扫