java基础郎波版chapter3习题

1.下列标识符哪些是合法的?

$88,#67,num,applet,Applet,7#T,b++,–b

合法：$88、num、applet、Applet、
不合法：7#T,b++,–b

2.Java有哪些基本数据类型?什么是复合数据类型?对于这两种类型的变量,系统的处理有什么不同?

基本数据类型：

整型：byte, short, int, long
浮点型：float, double
字符型：char
布尔型：boolean
这些基本类型直接存储值，并且每种类型占用固定的内存空间。它们的值直接保存在变量中，操作这些变量时直接对值进行操作。

复合数据类型：

类（Class）
数组（Array）
接口（Interface）
枚举（Enum）

复合数据类型不直接存储值，而是存储对数据的引用（内存地址），实际的数据存放在堆内存中。当操作这些类型的变量时，实际上是操作对数据的引用，而非数据本身。

系统处理的不同：

基本类型：存储在栈内存中，分配和销毁速度快，值直接存储，效率高，但不支持复杂的结构和方法。
复合类型：相比之下，引用类型（如对象、数组）的变量存储在栈上，但它们所引用的实际数据（对象实例）存储在堆中。当你创建一个对象时，JVM会在堆上分配内存来存储该对象的所有实例变量（包括基本类型和引用类型），然后栈上的引用变量会存储这个对象在堆中的内存地址。因此，虽然引用类型变量本身位于栈上，但它们指向的数据实体则位于堆中。

实例说明堆栈存放问题：

Person person = new Person("Alice", 30);

person这个变量作为引用存储在栈中。
new Person(“Alice”, 30)创建的对象实例（包括其属性name和age）存储在堆中。
当通过person调用方法或访问属性时，如person.getName()，程序先从栈中获取对象引用，然后通过该引用访问堆中对象的实际数据。

总结
因此，复合类型的存储特点可以概括为：引用在栈，实例（或数据）在堆。这种分离存储的方式，既保证了访问引用的高效性，又允许堆内存灵活管理大量的对象数据。

3.设变量i和j的定义如下,试分别计算下列表达式的值。

int i=1;double d=1.0
(1)35/4;
(2)46%9+44-2;
(3)45+43%5(233%2);
(4)45+4550%i–;
(5)45+4550%(–i);
(6)1.53十(十+d);
(7)1.5*3+d十+;
(8)i+=3/i十3。

解题：
(1)8
(2)15
(3)45+43%5*(69%2)=45+43%5=45+3=48

4.计算下列逻辑运算表达式的值。

(1)(true)&&(3>4);
(2)!(x>0)&&(x>0);
(3)(x>0)||(x<0);
(4)(x!=0)||(x0);
(5)(x>=0)||(x<0);
(6)(x!=1)!(x==1)。

题解：
(1)F
(2)F
(3)return x=0?false:true
(4)T
(5)F
(6)T

5.Java中有哪些类型的程序流控制语句?

6.switch语句与if语句可以相互转换吗?使用switch语句的优点是什么?

11.编写程序输出1000以内的所有奇数:

直接方法：

public class hellojava {
    public static void main(String[] args) {
        System.out.println("欢迎学习Java语言!");
        oddLessThan1000();


    }

    public static void oddLessThan1000(){
        int j=0;
     for (int i = 1; i < 1000; i++) {
         if (i % 2 == 1) {j++;
             System.out.print(i+"\t");
             if(j % 10== 0)
                 System.out.println();
         }

     }
 }
}

创建类的形式

奇数类

public class Odd {
    private int num;

    public Odd(int num)
    {
        this.num = num;
    }

    public void SetOdd(int num)
    {
        this.num = num;
    }

    public int getOdd()
    {
        return num;
    }

    public void OddLessNum(){
        for (int i = 1; i < num ; i++) {
            if (i % 2 == 1) {
                System.out.print(i+"\t");
            }
        }
    }

}

启动类

package com.example.demo;

import com.example.demo.chapter.Odd;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Demo1Application {

    public static void main(String[] args) {
        SpringApplication.run(Demo1Application.class, args);

//        创建odd对象，并初始化状态为100
        Odd odd = new Odd(100);
        System.out.println("odd.getOdd() = " + odd.getOdd());
        odd.OddLessNum();
        System.out.println();
//重新调用方法使得属相为1000
        odd.SetOdd(1000);
        System.out.println("odd.getOdd() = " + odd.getOdd());
        odd.OddLessNum();

    }
}

12.编写程序输出下列结果

1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
1 2 3 4 5 6

代码如下：

@SpringBootApplication
public class Demo1Application {

    public static void main(String[] args) {
        SpringApplication.run(Demo1Application.class, args);

        print(100);
    }

    public static void print(int num)
    {
        for (int i = 0; i < num; i++) {
            for (int j = 0; j < i; j++) {
                System.out.print(j+"\t");
            }
            System.out.println();
        }
    }
}

13.下列数组声明哪些是合法的?

(1)int i= new int(30);
(2)double d[]= new double[30];
(3)Integer[]r=new Integer(1…30);
(4)int i[]=(3，4，3，2);
(5)float f[]=(2.3，4.5，5.6);
(6)char[] c= new char();
(7)Integer[][] r = new Integer[2];

合法的数组声明有以下几项：

(2) double d[]= new double[30]; 这是一个正确的声明，它声明了一个可以存储30个double类型元素的数组。
(7) Integer[][] r = new Integer[2]; 这也是一个正确的声明，它声明了一个二维数组，其中第一维大小为2，每个元素是一个Integer类型的数组，但需要注意的是，这里的第二维大小没有指定，若要完全初始化，还需进一步为每个子数组分配内存，如 new Integer[2][3]。

其他选项的问题在于：

(1) int i= new int(30); 这是不合法的数组声明，应该是 int i[] = new int[30]; 或简写为 int[] i = new int[30];。
(3) Integer[]r=new Integer(1…30); 这是不合法的，Java中没有1…30这样的区间表示法，且new Integer(1…30)是错误的构造方式，应使用大括号 {} 初始化数组元素，如 Integer[] r = {1, 2, …, 30};，但直接这样初始化30个连续整数需要具体写出或通过循环生成。
(4) int i[]=(3，4，3，2); 不合法，数组初始化应该用大括号包围，即 int i[] = {3, 4, 3, 2};。
(5) float f[]=(2.3，4.5，5.6); 同样不合法，应使用大括号 {}，且浮点数需要指定为float类型，如 float f[] = {2.3f, 4.5f, 5.6f};。
(6) char[] c= new char(); 不合法，这试图声明一个未指定大小的字符数组，正确的形式应指定数组的大小，如 char[] c = new char[10]; 或直接初始化 char[] c = {‘a’, ‘b’, …};。

14.数组变量是基本类型变量还是引用型变量?数组的内存是在什么时候分配的?

数组变量本身是引用类型变量。在Java中，无论是基本类型数组还是对象数组，数组名实质上是一个引用，这个引用指向数组实例在堆内存中分配的实际空间。这意味着数组变量存储的是数组的内存地址，而非数组元素本身。

数组的内存分配发生在以下几个时刻之一：
显式声明并初始化时： 当使用 new 关键字创建数组时，例如 int[] array = new int[10];，这时会在堆内存中分配一个足够容纳10个整数的连续空间，并返回这块内存的地址给数组变量。
静态初始化时： 如 int[] array = {1, 2, 3};，同样地，数组实例在堆上被创建，元素值被设定，数组变量获得指向这块内存的引用。
简而言之，数组的内存是在数组被创建时分配的，这个过程通常伴随着数组变量的初始化。

15.编写程序,创建一个整型5x5矩阵,并将其输出显示。

@SpringBootApplication
public class Demo1Application {

    public static void main(String[] args) {
        SpringApplication.run(Demo1Application.class, args);
        
        fivefive();
    }
    
    public static void fivefive()
    {
        int[][] jz=new int[5][5];
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 5; j++) {
                jz[i][j]=i+j;
            }
        }
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 5; j++) {
                System.out.print(jz[i][j]+"\t");
            }
            System.out.println();
        }

    }
}