java课后作业（2,4,5,6）（持续更新）

第二章

1.java包含哪些数据类型？

基本数据类型：
(1)整型：byte、short、int、long.
(2)浮点型：float、double.
(3)字符型：char.
(4)布尔型：booleen.
复合数据类型：
(1)类class
(2)接口interface
(3)数组

2.java的基本数据类型转换包含哪两类？请举例说明。

(1)自动类型转换
public class javaConp{
public static void main(String args[]){
byte num = (byte)200;//int常量强制转换
System.out.println(num);//输出 byte 型变量
}
(2)强制类型转换
public class javaDemo{
public static void main(String args[]){
float x = (float)10.2;
float y = 10.1F;
}
}

3.为什么需要包装类？

引人包装类的目的如下(以int和Integer为例):
(1)基本数据类型不是对象,在一些场合不能直接使用(例如某些类方法参数必须是对象类型)，需要转化为对应的包装类对象才能继续使用。
(2)包装类的-些静态方法可实现不同数据类型的转化，如将字符串类型的数字"123"转为整数类型，可以通过int a= Integer. parseInt(“123”)完成，而将整数转为字符串使用，则要通过String c=String.valueOf(123)来完成。
(3)包装类的静态属性中含有相应数据类型的范围，如Integer.MIN_VALUE(int的最小值)，Integer.MAX_VALUE(int的最大值)，Double.NaN(非数类型)、Double.NEGATIVE-INFINITY(负无穷)、Double.POSITIVE_INFINITY(正无穷)。

4.int与integer有什么区别?他们之间的相互转化是怎样的？

区别：
(1)Integer是int的包装类，int则是java的一种基本数据类型.
(2)Integer变量必须实例化后才能使用，而int变量不需要.
(3)Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象；而int则是直接存储数据值.
(4)Integer的默认值是null，int的默认值是0.

5.逻辑运算符&和&&有什么区别？逻辑运算符&与位运算符的区别是什么？请分别举例说明。

(1)&和&&的区别：
例如A&&B,如果A为false，就不会去判断B是True还是False了。
而A&B，则如果A为false仍会执行一次B。
(2)逻辑运算符&与位运算符的区别:
逻辑运算符&左右两边是表达式，而位运算符&两边是二进制的数。

6.Java语言中可以采用什么语句跳出多重循环？请举例说明。

两种跳转方式：
(1)break

(2)break lab;

lab:
for(int i =0; i<2; i++) {
for(int j=0; j<10; j++) {
if (j >1) {
break lab;
}
System.out.println(“break");
}
}
//输出结果为：break，break；

第四章

1.对象与对象引用的区别是什么?请举例说明。

一、Java对象

所谓的对象其实就是通过java类所产生的实体。
java中可以通过构造类来产生对象
通过new + 构造方法就可以得到一个类的对象。因此上一个类中的构造方法就显得很重要，所以我们通过class关键字定义出来的java类，默认就是有一个无参数的构造方法存在，只不过我们没有显式写出这个无参数的构造。当出现有参数的构造方法时，最好能够显式写出这个无参数的构造方法。
类中的构造方法就是为了创建对象而存在的。

通过new 构造方法就可以得到一个类的对象是一个没有名称的对象，因此上也叫匿名对象。所以通常情况下我们都是需要定义/声明一个该类的变量来保存这个类的对象。我们把保存对象的这个类的变量又叫引用。【引用中实际上保存的是该对象在内存的实际地址】
例如：
public class MyTestClass {
public int testid=1001;
public String testname=“zhangsan”;
public MyTestClass(){
System.out.println(“无参数的构造方法–创建对象的时候要使用”);
}
public void method(){
System.out.println(“MyTestClass类中的实例方法”);
}
public static void staticMethod(){
System.out.println(“MyTestClass类中的类方法”);
}
}

二、Java对象的引用

每种编程语言都有自己的数据处理方式。有些时候，程序员必须注意将要处理的数据是什么类型。你是直接操纵元素，还是用某种基于特殊语法的间接表示（例如C/C++里的指针）来操作对象。所有这些在 Java 里都得到了简化，一切都被视为对象。因此，我们可采用一种统一的语法。尽管将一切都“看作”对象，但操纵的标识符实际是指向一个对象的“引用”（reference）。　对Java对象的引用，是描述的定义。
　　例如：
　　int a;
a=2;
a=3;
　　这里先声明了一个int类型的变量a，先对a赋值为2，后面又赋值为3。也就是说int类型的变量a，可以让它的值为2，也可以为3，只要是合法的int类型的数值即可。所以Java中的引用可以指向多个对象。

2.对象作为参数传递的特点是什么?请举例说明。

对象是引用传递，当对象作为参数传递的时候，传递的是参数的地址。

public class ValuePass {
private static int a;
public static void main(String [] args) {
modify(a);
System.out.println(a);
}
public static void modify(int a) {
a++;
}
}//值传递，输出为0

class IntClass {
int value;
}
public class RunIntClass {
public static void modifyValue(IntClass s, int val){
s.value = val;
}
public static void main(String[] args) {
IntClass a = new IntClass();
modifyValue(a,8);
System.out.println(a.value);
}
}//引用传递，值为8

3.对象初始化顺序是怎样的?请举例说明。

系统先对数据成员进行默认初始化
执行数据成员定义处的初始化语句
调用构造方法为数据成员指定初值

class IntClass {
int value; //自动初始化，默认值为0
//int value = 5； //在定义时指定初值

public IntClass（）{}

//定义构造方法将属性value初始化
public IntClass（int val）{
value = val ；
}
}

4.类的static字段与非static字段的区别是什么?什么情况应该使用static修饰符?请举例说明。

(1)类的static字段修饰的域变量不属于任何一个类的具体对象，而专属与类。
(2）用static修饰符修饰的方法称为静态方法，它属于类方法，不属于类的任何对象。


静态数据成员仅在类加载时进行初始化，且只执行一次初始化

5.Java中final修饰符 都有什么作用?请举例说明。

以final修饰类属性，则该属性为常量，如果修饰方法，则方法称为最终方法，在子类中不能被覆盖。利用这一点可以防止子类修改此方法，保证了程序的安全性和正确性。

public F{
2 static final int a = 0;//a的值不能被覆盖
3 static final ff（）{}//方法不能被重写

6.Java中float[10] arr;语句正确么?为什么?

不正确，数组的声明中不能初始化数组的长度。

7.Java数组元素类型为基本数据类型和引用类型时，有什么不同?请举例说明。

区别：数组元素类型为基本元素类型时；数组中存储的就是所要使用的值，而数组元素类型为引用类型的时候，数组中存储的不是所用的值，而是通过存储的引用来查找到所需值的地址。
例：
int[] arr = new int[10]; //此时分配了数组空间，每个单元初始化为默认值0

产生一个有10个单元，类型为int的数组对象，所有单元的初始值为0；

例：
String[]example = new String[10]; //对象引用数组

产生一个具有10个单元的数组对象，每个单元存放的是一个String对象的引用，所有单元的初值为null，此时并未创建具体的String对象。

第五章

1. Java的访问控制修饰符有哪些？各有什么访问权限？请对照第7页ppt的表格分别写程序验证。

访问权限首先看类前的修饰符，当类的修饰符为public时，
则类可以被所有的类所访问（可以import），当为默认时，
则只能为包中的类所访问。在此前提下，再看属性和方法前的修饰符。

类前修饰符为public时，当属性和方法前的修饰符为public时，则该属性可以被所有类访问；当属性和方法前为protected修饰时，对于类定义而言，可以被同包中的类和所有子类访问（子类和父类可以不在同一个包中），也就是B+C范围，但对于对象而言，只能被同一个包的类对象所访问，也就是B的范围；当为默认时，只能被同包中的类所访问（比protected访问权限小）；当为private时，只能被本类内部所访问 。

同一个包——演示public类的protected属性访问：


不同包——演示public类的protected属性访问：

2. 子类对于从父类继承的哪些属性与方法是可见的？请分别写程序进行验证。

父类的public和proected的属性与方法对子类来讲是可见的。

3. 什么是组合？有什么作用？请举例说明。

组合是在一个类的内部应用了别的类的引用，通过现有的对象进行拼装产生新的、更加复杂的功能。
class FighterPlane
{
String name;
int missileNum;
public FighterPlane(String _name,int _missileNum){
name = _name;
missileNum = _missileNum;
}
public void fire(){
if (missileNum>0){
System.out.println(“now fire a missile !”);
missileNum -= 1;
}
else{
System.out.println(“No missile left !”);
}
}
}

class A
{
FighterPlane fp;
public A(FighterPlane fpp){
this.fp = fpp; //A对象中拥有了FighterPlane对象的引用
}
public void invoke(){
//A中对象发送消息给FighterPlane的对象
System.out.println(fp.name);
}
}
public class Run{
public static void main(String[] args)
{
FighterPlane ftp = new FighterPlane(“su35”,10);
//产生A对象，并将ftp对象引用作为参数传入
A a = new A(ftp);
//发送消息，产生调用关系
a.invoke();
}
}

4. 什么是重载？有什么作用？请举例说明。

重载：方法名称相同，参数类型或个数不同。重载可以对其功能进行复用，同时又可以对其进行补充。

class Parent{
public int getScore(){
return 3;
}
public int getScore(int i){
return i;
}

}

5. 什么是覆盖？有什么作用？请举例说明。

子类对父类的同名方法（方法名称相同，参数相同，返回类型相同）重新进行定义，即在子类中定义与父类中已定义的同名而内容不同的方法。

class Parent {
public int getScore()
{ return 3; }
public String getCountryName()
{ return “China”; }
}
class Son extends Parent {
public int getScore(){
return 4;
}
}
public class RunSon{
public static void main(String args[]){
Son s = new Son();
System.out.println(s.getScore());
System.out.println(s.getCountryName());
}
}

第六章

2.如何实现两个对象之间互发消息，请举例说明。

1）引用必须真实引用了特定的对象。
2）被访问对象必须定义了相应的属性或方法。否则编译不通过
3）被访问的属性或方法必须具有可访问的权限。

class FighterPlane{

String name;
int missileNum;
public FighterPlane(String _name,int _missileNum){
name = _name;
missileNum = _missileNum;
}
public void fire(){
if (missileNum>0){
System.out.println(“now fire a missile !”);
missileNum -= 1;
}
else{
System.out.println(“No missile left !”);
}
}
}

class A
{
FighterPlane fp;
public A(FighterPlane fpp){
this.fp = fpp; //A对象中拥有了FighterPlane对象的引用
}
public void invoke(){
//A中对象发送消息给FighterPlane的对象
System.out.println(fp.name);
}
}
public class Run{
public static void main(String[] args)
{
FighterPlane ftp = new FighterPlane(“su35”,10);
//产生A对象，并将ftp对象引用作为参数传入
A a = new A(ftp);
//发送消息，产生调用关系
a.invoke();
}
}

6.简述instanceof的使用场景

用instanceof判断一个对象是不是某个类或者其子类的实例，还可以将这个对象强制转换成这个类的类型。
a为对象的引用，A为类。如果a是A或其子类的实例，则返回true，若为A父类的子类，则返回false。若无关，则错误

public class Test {
static class A{ }
static class B extends A{ }

public static void main(String[] args) {
A a = new A();
B b = new B();

System.out.println( “a instanceof A 的结果:” + ( a instanceof A ) );
System.out.println( “b instanceof A 的结果:” + ( b instanceof A ) );
System.out.println();
System.out.println( “a instanceof B 的结果:” + ( a instanceof B ) );
System.out.println( “b instanceof B 的结果:” + ( b instanceof B ) );
System.out.println();

Object o = new A();
System.out.println( “o instanceof A 的结果:” + ( o instanceof A ) );
System.out.println( “o instanceof B 的结果:” + ( o instanceof B ) );
System.out.println();

o = new B();
System.out.println( “o instanceof A 的结果:” + ( o instanceof A ) );
System.out.println( “o instanceof B 的结果:” + ( o instanceof B ) );
System.out.println();
}
}