JAVA程序设计实用教程 第三章 习题3（1）

3-1  什么是类？什么是对象？他们之间的关系是怎样的？p66

类（Class）是面向对象程序设计（OOP，Object-Oriented Programming）实现信息封装的基础。类是一种用户定义的引用数据类型，也称类类型。每个类包含数据说明和一组操作数据或传递消息的函数。类的实例称为对象

对象是人们要进行研究的任何事物，它不仅能表示具体的事物，还能表示抽象的规则、计划或事件。对象具有状态，一个对象用数据值来描述它的状态。对象还有操作，用于改变对象的状态，对象及其操作就是对象的行为。对象实现了数据和操作的结合，使数据和操作封装于对象的统一体中。

类（class）和对象 (object)是两种以计算机为载体的计算机语言的合称。

. 对象是对客观事物的抽象，

.是对对象的抽象。

. 类是一种抽象的数据类型。

. 它们的关系是，对象是类的实例，类是对象的模板

3-2  作为引用数据类型，在赋值和方法的参数传递方面，对象与基本数据类型的变量有什么不同？

基本数据类型，操作传递的是变量的值，改变一个变量的值不会影响另一个变量的值。

引用数据类型（类，数组和接口），赋值是把原对象的引用（可理解为内存地址）传递给另一个引用

3-3  以下方法能否实现交换两个对象的功能？为什么？

public static void swap(Object x,Object y) {
		Object temp=x;
		x=y;
		y=temp;
	}

public static void swap(Object[] objs,int i,int j) {  //交换对象objs[i]与objs[j]值
		if(objs!=null&&i>=0&&i<objs.length&&j>=0&&j<objs.length&&i!=j) {  //避免下标越界
			Object temp=objs[j];
			objs[j]=objs[i];
			objs[i]=temp;
		}
	}

  第一个：

// A Java program to demonstrate that simply swapping
// object references doesn't work

// A car with number and name
class Car
{
    int model, no;

    // Constructor
    Car(int model, int no)
    {
        this.model = model;
        this.no = no;
    }

    // Utility method to print Car
    void print()
    {
        System.out.println("no = " + no +
                           ", model = " + model);
    }
}

// A class that uses Car
class Main
{
    // swap() doesn't swap c1 and c2
    public static void swap(Car c1, Car c2)
    {
        Car temp = c1;
        c1 = c2;
        c2 = temp;
    }

    // Driver method
    public static void main(String[] args)
    {
        Car c1 = new Car(101, 1);
        Car c2 = new Car(202, 2);
        swap(c1, c2);
        c1.print();
        c2.print();
    }
}

输出：

no = 1, model = 101
no = 2, model = 202

从上面的输出可以看出，对象没有交换成功。所以当我们传给swap方法c1与c2的时候，这个方法就创建了这两个引用的副本。

用封装类（Wrapper Class）解决，如果我们建立一个封装类，这个类包含Car的引用，我们可以通过交换封装类的引用来交换这两个car。

// A Java program to demonstrate that we can use wrapper
// classes to swap to objects

// A car with model and no.
class Car
{
    int model, no;

    // Constructor
    Car(int model, int no)
    {
        this.model = model;
        this.no = no;
    }

    // Utility method to print object details
    void print()
    {
        System.out.println("no = " + no + 
                           ", model = " + model);
    }
}

// A Wrapper over class that is used for swapping
class CarWrapper
{
   Car c;

   // Constructor
   CarWrapper(Car c)   {this.c = c;}
}

// A Class that use Car and swaps objects of Car
// using CarWrapper
class Main
{
    // This method swaps car objects in wrappers
    // cw1 and cw2
    public static void swap(CarWrapper cw1, 
                            CarWrapper cw2)
    {
        Car temp = cw1.c;
        cw1.c = cw2.c;
        cw2.c = temp;
    }

    // Driver method
    public static void main(String[] args)
    {
        Car c1 = new Car(101, 1);
        Car c2 = new Car(202, 2);
        CarWrapper cw1 = new CarWrapper(c1);
        CarWrapper cw2 = new CarWrapper(c2);
        swap(cw1, cw2);
        cw1.c.print();
        cw2.c.print();
    }
}

输出：

no = 2, model = 202
no = 1, model = 101

3-4  面向对象有哪些核心特性？

1、面向对象有封装、继承 、抽象、多态等4个主要的特征。
2、封装：面向对象的封装就是把描述一个对象的属性和行为的代码封装在一个类中，有些属性是不希望公开的，或者说被其他对象访问的，所以我们使用private修饰该属性，使其隐藏起来；类中提供了方法（用public修饰），常用的是get、set方法，可以操作这些被隐藏的属性，其他类可以通过调用这些方法，改变隐藏属性的值！

封装是保证软件部件具有优良的模块性的基础，封装的目标就是要实现软件部件的“高内聚、低耦合”，防止程序相互依赖性而带来的变动影响。在面向对象的编程语言中，对象是封装的最基本单位，面向对象的封装比传统语言的封装更为清晰、更为有力。

3、抽象：抽象就是找出一些事物的相似和共性之处，然后将这些事物归为一个类，这个类只考虑这些事物的相似和共性之处，并且会忽略与当前主题和目标无关的那些方面，将注意力集中在与当前目标有关的方面。

4、继承：在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，使用extends关键字实现继承；子类中可以加入若干新的内容，或修改原来的方法使之更适合特殊的需要，这就是继承。继承是子类自动共享父类数据和方法的机制，这是类之间的一种关系，提高了软件的可重用性和可扩展性。

5、多态：Java引用变量有两种类型，分别是编译时类型(原型)和运行时类型，编译时类型由声明类型决定，运行时类型由赋值对象的类型决定。如果编译时类型和运行类型不一致，就会出现所谓多态。
可以这样理解：多态是指通过父类型的变量引用不同的子类对象（也就是说父类型变量指向的是一个子类对象，JVM会在运行时动态的绑定父类型变量所指向的子类对象）,来调用在不同子类中实现的方法。
多态就是在声明时使用父类，在实现或调用时使用具体的子类；即不修改程序代码就可以改变程序运行时所绑定的具体代码，多态增强了软件的灵活性和扩展性。这里可以举个例子，比如声明时使用的是动物类，调用时传递的是一个猫类（动物类的子类）的对象，具体执行父类里动物——吃的方法时，实际执行的是猫——吃的方法。
多态依赖于向上转型和后期绑定。

3-5  什么是封装？为什么将类封装起来？封装的原则是什么？有哪些封装手段？p70

1、封装的含义：封装是实现面向对象程序设计的第一步，封装就是将数据或函数等集合在一个个的单元中（我们称之为类）。被封装的对象通常被称为抽象数据类型。

2、封装的作用：封装的作用在于保护或者防止代码（数据）被我们无意中破坏。在面向对象程序设计中数据被看作是一个中心的元素并且和使用它的函数结合的很密切，从而保护它不被其它的函数意外的修改。

3.封装原则：隐藏对象的属性和实现细节，仅对外公开接口，并且控制访问级别
在OOP（面向对象）编程中，用类来实现上面的要求。用类实现封装，用封装来实现高内聚，低耦合

4、如何封装：封装提供了一个有效的途径来保护数据不被意外的破坏。相比我们将数据（用域来实现）在程序中定义为公用的（public）我们将它们(fields)定义为私有的（private）在很多方面会更好。私有的数据可以用两种方式来间接的控制。第一种方法，我们使用传统的存、取方法。第二种方法我们用属性（property），使用属性不仅可以控制存取数据的合法性，同时也提供了“读写”、“只读”、“只写”灵活的操作方法。
 

3-6  

3-7  说明一个类的默认构造方法的必要性，java在什么情况下提供默认构造方法？p70

当一个类没有声明构造方法时，java会自动为该类提供一个无参数的默认构造方法，对各成员变量进行初始化。如果一个类声明了构造方法，java不再提供默认构造方法。

3-8  

3-9为什么java不提供默认拷贝构造方法？当对象作为方法的参数和返回值时，参数是如何传递的？p81

java不提供默认拷贝构造方法，因为java的类采用引用模型，当对象作为方法的参数和返回值时，传递对象引用，不需要复制对象，没有执行拷贝构造方法。

当一个对象作为参数，传递到方法当中时，实际上传递进去的是对象的地址值。

class person
{
	String name;
	String address;
	String tele;
	
	public person()
	{
	}
	public person(String name,String address,String tele)
	{
		this.name = name;
		this.address= address;
		this.tele= tele;
	}
	
	void show(person o)
	{
		o.name="adsj0";
		System.out.println(name+address+tele);
	}
	void show()
	{
		System.out.println(name+address+tele);
	}

}
class Main
{
	public static void main(String args[])
	{
		person p = new person("杜春风","山洞里的大学","110");
		p.show();
		p.show(p);
		p.show();
	}
	
}

当使用一个对象类型作为返回值时，返回值其实就是对象的地址值。

class person
{

}

class Main
{
	public static void main(String args[])
	{
		person pp=text();
		System.out.println(pp);
	}
	
	public static person text() {
		person p=new person();
		System.out.println(p);
		return p;
	}
	
}

 3-10  this引用有什么作用？this引用有几种使用方法？举例说明。p71

1.指代对象

2.调用本类重载的构造方法

3.访问本类的成员变量和成员方法

class person
{
	String name;
	String address;
	String tele;
	public person()
	{
	}
	public person(String name,String address)
	{
		this.name = name;       //3.访问本类的成员变量和成员方法
		this.address= address;  
	}
	public person(String name,String address,String tele)
	{
		this(name,address);//2.调用本类重载的构造方法
		this.tele= tele;
	}
	void show()
	{
		System.out.println(name+address+tele);
	}
	person text() {
		return this;  //1.指代对象
	}
}
class Main
{
	public static void main(String args[])
	{
		person p = new person("杜春风","山洞里的大学","110");
		p.show();
		person ptext=p.text();
		System.out.println(ptext.name);
	}
	
}

3-11  java语言定义了几个关键字用于表示几种访问权限？各表示什么含义？类有几种访问权限？类中成员有几种访问权限？分别用什么关键字表示？p73

private ： Java语言中对访问权限限制的最窄的修饰符，一般称之为“私有的”。被其修饰的属性以及方法只能被该类的对象访问，其子类不能访问，更不能允许跨包访问。

default： 即不加任何访问修饰符，通常称为“默认访问权限“或者“包访问权限”。该模式下，只允许在同一个包中进行访问。

protected: 介于public 和 private 之间的一种访问修饰符，一般称之为“保护访问权限”。被其修饰的属性以及方法只能被类本身的方法及子类访问，即使子类在不同的包中也可以访问。

public： Java语言中访问限制最宽的修饰符，一般称之为“公共的”。被其修饰的类、属性以及方法不仅可以跨类访问，而且允许跨包访问。
 

类有两种访问权限，公有（public）和缺省（无修饰符）

公有可被所有包中的其他类访问

缺省只能被当前包的其他类访问

类的成员有四种访问权限，私有（private），缺省（无修饰符），保护（protected），公有（public）

私有成员只能被当前类的成员访问

缺省成员可以被当前类及当前包中的其他类访问

保护成员能被当前类及其子类或当前包的其他类访问

公有成员可被所有类访问

3-12  如果MyDate类声明如下,有哪些错误,为什么

private class MyDate{  //1.class不能用private修饰
	public int year,month,day;
	void set(int y,int m,int d=1) {  //2.d不能赋初值
		int year=y;
		month=m;
		day=d;
	}
	public static void main(String[] args) {
		MyDate d1,d2=...;  //3.应该实例化类
		System.out.println("d1:"+d1.toString()+", d2:"+d2+",d1>d2?"+(d1>=d2));
	}
}

1.class不能用private修饰

2.d不能赋初值

3.应该实例化类

3-13  为什么MyDate类中，可以重载set（）方法，而不能重载get（）方法？p74

public void set(int year,int month,int day)
public void set(MyDate date)
public int getYear()
public int getMonth()
public int getDay()

因为两个set（）方法的参数列表不同，所以可以重载

get（）方法参数列表相同，不能重载

3-14  说明静态成员与实例成员的区别

静态成员具有下列特征：
— 静态成员必须通过类名使用 . 运算符来引用，而不能用对象来引用。
— 一个静态字段只标识一个存储位置。无论创建了一个类的多少个实例，它的静态字段在内存中都只占同一块区域。
— 静态函数成员（方法、属性、事件、运算符或构造函数）不能作用于具体的实例，在这类函数成员中不能直接使用实例成员，必须通过类名来引用。
实例成员具有以下特点：
— 实例成员必须通过对象名使用 . 运算符来引用，而不能用类名来引用。
— 类的实例字段属于类的实例所有，每创建一个类的实例，都在内存中为实例字段开辟了一块区域。类的每个实例分别包含一组该类的所有实例字段的副本。
— 实例函数成员（方法、属性、索引器、实例构造函数或析构函数）作用于类的给定实例，在它们的代码体内可以直接引用类的静态和实例成员。