3 Java 第三章练习1

3 Java 第三章练习1

1、下面Java代码的运行结果是

package day2;

public class Dog {
    String name=null;  //声明变量
    int age = 10;
    public Dog() {    //构造方法：为对象赋初始值
        this.name = "旺财";
        this.age = 20;
    }
    public void show(){ //声明方法
        System.out.println("名字:"+name+" 年龄:"+age);
    }
    public static void main(String[] args) {
        new Dog().show();  //创建对象
    }
}
    //名字:旺财 年龄:20

2、在Java中，以下程序编译运行后的输出结果

package day2;

public class Test {
    int x = 2; // 声明变量
    int y = 4;
    Test (int x, int y) {  //构造方法
        this.x = x;
        this.y = y;
    }
    public static void main(String[] args) {
        Test pt1 = new Test (3, 3);  //创建了一个对象pt1
        Test pt2 = new Test (4, 4);     //创建了一个对象pt2
        System. out. print (pt1.x + pt2.x);
    }
}//7

3、写出结果

package day2;

public class Test1 {
    int i = 0;  //声明变量
    void change(int i) {   //声明方法1  参数是基本数据类型 值传递
        i++;  //this.i++；输出的i就是1
        System.out.println(i);
    }
    void change1(Test1 t) {  //声明方法2   参数是引用数据类型  传递对象堆内存中的地址
        t.i++;
        System.out.println(t.i);
    }

    public static void main(String[] args) {
        Test1 ta = new Test1();  //创建一个对象ta
        System.out.println(ta.i); //0
        ta.change(0);   //1  
        System.out.println(ta.i);//0  把0传递给方法，方法里的i变成1，但是堆里面放着的对象里面的i没有改变,还是0，因为它传递的是数值
        ta.change1(ta); //1
        System.out.println(ta.i);//1  //ta和t存储的是地址， 指向同一个对象的地址
    }
}   //01011

4、写出结果

i=10
i=10

day2.Demo@1b6d3586
day2.Demo@1b6d3586
d.i : 5
d.i = 6

package day2;

public class TestArgsValue{

    public static void main(String[] args) {
        int i = 10;
        TestArgsValue tv = new TestArgsValue();  //创建对象tv
        tv.method1(i);  // 10  这里输出的是对象中的i
        System.out.println("i=" + i); //10    对象在堆里面 ，运行方法在栈里面，值传递时 栈里面i改变，和堆里面对象中的i无关

        System.out.println();
        Demo d = new Demo(); //创建对象d  i=5
        System.out.println(d); //5
        
        tv.method2(d);    // int 类型传递给引用类型  出错
        
        System.out.println("d.i = " + d.i); //d.i= 6
    }

    public void method1(int i){      //参数是基本数据类型，所以是 值传递
        System.out.println("i=" + i++);
    }

    public void method2(Demo d){     //参数是引用数据类型，所以是引用传递，传的是对象的地址
        System.out.println(d); //5
        System.out.println("d.i : " + d.i++); //d.i: 5
    }

}

class Demo{   //Demo类
    int i = 5;
}

5、写出结果

test static
person static
person Test
test
test constructor

package   day2;

public class Test4 {
    Person person = new Person("Test");   //对象person
    //声明变量
    int age;
    static{   //静态代码块 静态代码块先执行
        System.out.println("test static");
    }
    {        //实例代码块
        System.out.println("test");
    }

    //声明方法
    public Test4() {
        System.out.println("test constructor");
    }

    public static void main(String[] args) {
        new Test4(); //新建一个对象
    }

}

class Person{
    static{  //静态代码块
        System.out.println("person static");
    }
    public Person(String str) {   //参数：引用类型数据，传对象的地址
        System.out.println("person "+str);
    }
}

6、写结果

package day2;

public class Test2{
    public static void leftshift(int i, int j){  //static修饰方法，在类的模板上默认初始化0,0
        i+=j;
    }
    public static void main(String args[]){
        int i = 4;
        int j = 2;
        leftshift(i, j);
        System.out.println(i); //4
    }
}

7、哪个选项和show()重载

class Demo{
void show(int a,int b,float c){ }
} acd都是 ，

A.void show(int a,float c,int b){ }
B,void show(int a,int b,float c){ }
C.int show(int a,float c,int b){ return a; }
D.int show(int a,float c){ return a; }

方法重载： 方法名字一样，参数不同（参数类型，参数顺序，参数个数）

方法重载： 方法使用功能扩展

8、编程

比较大小：分别利用重载，对两个int,两个double，三个int，三个double类型的数进行比较大小,返回其中较大的一个.

9、编程

定义一个中国邮政储蓄银行类，
属性:账号、密码、存款余额,银行名称。
方法:注册账号、存款、取款、查询。
创建该类对象并测试注册账号,存钱,取钱查询操作
要求:使用面向对象思想设计程序

package day2;

import java.util.Scanner;

/*
   定义一个中国邮政储蓄银行类，
      属性:账号、密码、存款余额,银行名称。
      方法:注册账号、存款、取款、查询。4 退出
      创建该类对象并测试注册账号,存钱,取钱查询操作
	  要求:使用面向对象思想设计程序
 */
public class ChineseBankTest {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        //输出台   执行一次
        System.out.println("------CHINA BANK-------");
        System.out.println("请按以下步骤执行操作：");
        System.out.println("1 注册账号");
        System.out.println("2 登录");
        System.out.println("-----------------------");

        //注册 register()  执行一次
        ChineseBank cb = new ChineseBank();
        cb.register();

        //登录  循环执行
        System.out.println("输入账号：");
        String acc = scanner.next();
        System.out.println("输入密码：");
        int pas = scanner.nextInt();
        outer:while(true){

            if(acc.equals( cb.account) && pas == cb.password){
                //进入系统
                System.out.println("------CHINA BANK-------");
                System.out.println("请选择要执行的操作：");
                System.out.println("1 存款");
                System.out.println("2 取款");
                System.out.println("3 查询");
                System.out.println("4 退出");
                System.out.println("-----------------------");

                int choice = scanner.nextInt();
                switch(choice){
                    case 1: //deposit 存款
                        cb.deposit();
                        break;
                    case 2:  //withdrawal 取款
                        cb.withdrawal();
                        break;
                    case 3:
                        System.out.println(ChineseBank.name+"提示您：您账户余额为："+cb.balance);
                        break;
                    case 4:
                        break outer;
                    default:
                        System.out.println("无效输入！");
                }
            }else{
                System.out.println("账号密码不正确，请重新输入。");
            }

        }

    }
}

package day2;

import java.util.Scanner;

/*
   定义一个中国邮政储蓄银行类，
      属性:账号、密码、存款余额,银行名称。
      方法:注册账号、存款、取款、查询。4 退出
      创建该类对象并测试注册账号,存钱,取钱查询操作
     要求:使用面向对象思想设计程序
 */
public class ChineseBank {

    Scanner scanner = new Scanner(System.in);

    //声明变量
    String account = "";
    int password = 0;
    double balance = 0;//余额
    public static String name = "CHINA BANK";


    //构造方法
    ChineseBank(){
        this.account = account;
        this.password = password;
        this.balance = balance;
    }

    //声明方法
    public void register(){
        /*
        register 注册账号
         */
        System.out.println("请输入账号：");
        account = scanner.next();
        System.out.println("请输入密码：");
        password = scanner.nextInt();
        System.out.println("注册成功！");
        System.out.println("记住你的账号："+account+"\t密码："+password);
    }
    public void deposit(){
        /*
        deposit 存款
         */
        double temp;
        System.out.println("请输入存款数：");
        temp = scanner.nextDouble();
        balance +=temp;
        System.out.println("成功存入："+temp+"\t余额:"+balance);
    }
    public void withdrawal(){
        /*
        withdrawal 取款
         */
        double temp;
        System.out.println("请输入取款数：");
        temp = scanner.nextDouble();
        balance -=temp;
        System.out.println("成功取出："+temp+"\t余额:"+balance);
    }
    public double search(){
        // 查询余额
        return balance;
    }
}

10、简答

1.面向对象编程的思想.

面向对象：以分类方式思考问题和解决问题。先对整体分类，再根据不同类深入细节处理。

比如：动物就是一个类，动物里面有老虎，狮子，大象等，而老虎、狮子、大象都是动物类的具体对象，

面向过程：分析解决问题的步骤，每个步骤进行实现，使用时依次调用。

例如把大象装冰箱：

面向对象：

设计一个冰箱类( 抽象的)

public class 冰箱{

​ 名字

​ 型号

​ 价格

​ 开门( );

​ 装大象();

​ 关门();

​ }
冰箱 bx = new 冰箱(); //在运行 时在内存中会划出一块空间,用来存储具体的对象

​ bx. 开门()

​ bx. 装大象()

面向对象是在宏观整体上对事物之间的关系进行设计,

具体实现又回归到面向过程的具体实现.

两者是相辅相成的.

面向过程：

第一步：打开冰箱， 开冰箱(){}

第二步：放大象，放大象(){}

第三步：关闭冰箱，关冰箱(){}

面向对象和面向过程是一种编程思想。

2.说明类与对象的关系.

类：类是抽象的，不占内存，占用存储空间。

对象：对象是具体的，占据内存。

关系：通过类创建对象，对象是类的一个实例，类是对象的抽象。

类和对象就如同 动物和老虎的关系。

3.简述构造方法的作用,特征,方法重载.

构造方法作用：为创建的对象初始化赋值。

特征：

• 构造方法名和类名相同，无void,无返回值。

• 每创建一个对象，至少要调用一个构造方法。如果没有参数，把默认构造方法显示地写出来。

  无参构造方法：默认无参构造方法

  有参构造方法： 必须声明this.name = name； this.name是正在使用的对象的name

方法重载：方法名相同，但是参数不同(类型、顺序、个数) 构造方法重载、成员变量方法重载

4.简述静态变量和非静态变量的区别？static

静态变量：static 修饰，能被所有对象共享，可以通过类名调用，static修饰的优先

非静态变量：不能被共享，不能被类名调用，只能创建对象调用

11、总结. 不会的

4