作业2：2018/7/4

1:局部变量和成员变量的区别?
（1）、在类中的位置不同
成员变量：在类中方法外面；有static关键字修饰，就叫作静态变量或类变量；没有static关键字修饰，就叫作非静态变量或实例变量；
局部变量：在方法或者代码块中，或者方法的声明上（即在形式参数列表中）
（2）、在内存中的位置不同
成员变量：在堆中（方法区中的静态区）
局部变量：在栈中
（3）、生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用或者代码块的执行而存在，随着方法的调用完毕或者代码块的执行完毕而消失
（4）、初始值
成员变量：成员变量可以不显式初始化，有默认初始值
局部变量：没有默认初始值，使用之前需要赋值，否则编译器会报错（The local variable xxx may not have been initialized）

2:形式参数分别为基本类型和引用类型的区别?请举例说明情况
首先要弄清什么是形式参数，基本类型，引用类型；
形式参数（形参）百度百科里的解释是：在定义函数名和函数体的时候使用的参数,目的是用来接收调用该函数时传入的参数.
通俗的说就是：形式参数是指在函数名后面的小括号里定义的变量, 用于接受来自调用函数的参数。
基本类型：四类八种，储存的是数据本身 byte short int long float double boolean char
引用类型：储存的是地址值 比如 类，接口，集合之类的，java中的包装器类型就是引用类型；
可以张这样理解，c/c++中的指针和引用类型本质一样，在C++中还有一个专门的引用操作符
然后：
　　对于基本类型，形式参数的改变不会影响实际参数
　　对于引用类型，形式参数的改变会直接影响实际参数
再然后：就是形式参数分别是基本类型和引用类型的调用

3:匿名对象是什么?应用场景是什么?
（1）：什么是匿名对象？
没有名字的对象。
（2）：匿名对象应用场景。
调用方法，仅仅只调用一次的时候。
a.这种匿名调用有什么好处？节省代码。
b.注意：调用多次的时候，不适用。匿名对象调用完毕即为垃圾，可以被垃圾回收器回收。
实例一：
//匿名对象是否可以调用属性并赋值?有什么意义?
/*
匿名对象可以调用属性,但是没有意义,因为调用后就变成垃圾
如果需要赋值还是用有名字对象
*/
new Car().color = “red”;
new Car().num = 8;
new Car().run();
实例二：匿名对象可以当作参数传递
//Car c2 = new Car();
//method(c2);
method(new Car()); //匿名对象可以当作参数传递

4:封装是什么?java中封装的体现有哪些?请举例说明。
(1)封装的—安全特性
(2)封装的第二个好处-将变化隔离
(3)封装便于使用
(4)提供重复性的特性。
封装的好处：
1：隐藏了类的具体实现
2：操作简单
3：提高对象数据的安全性
体现：
private， protected， public关键字的使用

5:this关键字是什么?this关键字的应用场景?
(1)this关键字用来指向当前对象或类实例
(2)this可以用于构造函数调用其他构造函数。
但注意：只能定义在构造函数的第一行。因为初始化动作要先执行。

6:构造方法的作用是什么?构造方法的特点是什么?构造方法的注意事项是什么?构造方法中可不可以写return语句呢?
a、作用：
构造方法:也就是类的初始化方法,初始化一个对象，给对象赋值,每个java类实例化的时候都会调用一个构造方法
b、特点：
方法名与类名同名，没有返回类型，连void也没有，没有具体的返回值；
c、注意事项：
(1)如果没有手动编写的话会有一个默认的无参构造方法,
(2)构造方法可以被重载 也就是可以有多个名字相同参数不同的方法
d、可以有返回语句return;

7:给成员变量赋值有几种方式?
(1)通过成员函数来赋值 eg: obj.setPerproties()
(2)通道构造函数来赋值,给一个对象赋值初始化

8:标准的代码编写及测试：
A:学生类的案例
B:手机类的案例
C:长方形类的案例
9:简述一个类的成员变量初始化过程
Student s = new Student();

”’
//Person类
package test;

public class Person {
protected String m_ID;
protected String m_name;
protected String m_sex;
protected int m_age;
protected String m_degree;
protected String m_college;

public Person() {

    m_ID = "1234";
    m_name = "Tom";
    m_sex = "male";
    m_age = 0;
    m_degree = "undergraduate";
    m_college = "XiYou";

    System.out.println("I'm class Person");
}

public Person(String ID, String name, String sex, Integer age, String degree, String college) {

    this.m_ID = ID;
    this.m_name = name;
    this.m_sex = sex;
    this.m_age = age;
    this.m_degree = degree;
    this.m_college = college;
}

public void viewInforamtion() {
    System.out.println("ID : " + m_ID);
    System.out.println("name : " + m_name);
    System.out.println("sex : " + m_sex);
    System.out.println("age : " + m_age);
    System.out.println("degree : " + m_degree);
    System.out.println("college : " + m_college);
}

public void sayHello() {
    System.out.println("I'm clsss Person");
}

@Override
public String toString() {
    return getClass().getName();
}

@Override
public boolean equals(Object object) {
    if (this == object){
        return true;
    }

    if(object instanceof Person) {
        Person person = (Person)object;
        if(!this.m_name.equals(person.m_name)) {
            return false;
        }
        if(this.m_ID != person.m_ID) {
            return false;
        }
        if (this.m_age != person.m_age) {
            return false;
        }

        return true;
    }

    return false;
}

@Override
public int hashCode() {
    return m_ID.hashCode();
}

}

//Father类
package test;

import java.util.Scanner;

public class Father extends Person {

public Father() {
    System.out.println("I'm father.");
}

@Override
public void viewInforamtion() {

}

// 重写父类的方法
@Override
public void sayHello() {
    System.out.println("I'm father");
    this.viewInforamtion();
}


public void changeInfomation() {
    System.out.println("What type info want you change?");
    System.out.println("Please input a int value of reflect...");
    System.out.print("Please input : ");
    Scanner scanner = new Scanner(System.in);
    int n = scanner.nextInt();

    System.out.print("Please input info:");
    String temp = scanner.next();
    scanner.close();


    boolean flag = true;

    switch(n) {
    case 1: m_ID = temp; break;
    case 2: m_name = temp; break;
    case 3: m_sex = temp; break;
    case 4: m_degree = temp; break;
    case 5: m_college = temp; break;
    default:System.out.println("Error option"); 
            flag = false;
            break;
    }

    if(flag) {
        System.out.println("Have changed successfuly!");
    }   
}

public void deleteInformation() {

}

public void addInformation() {

}

}

//Student类：
package test;

import test.Father;
import test.Subject;

public class Student extends Father {

// 学科及成绩信息类
private Subject subject;

public Student() {
    super();
    subject = new Subject();

    System.out.println("I'm a student.");
}

// 重写父类的方法
@Override
public void sayHello() {
    System.out.println("I'm a student");
}

// 查看信息
@Override
public void viewInforamtion() {
    super.viewInforamtion();
    System.out.println(subject.getCourse() + " : " + subject.getScore());
}

// 爸爸
public String callFather() {
    return super.m_name;
}

// 老师
public String callTeacher() {
    return "";
}

// 修改信息
public void changeInfomation(String id) {
    if(this.m_ID.equals(id)) {

    }
}

// 删除信息
public void deleteInformation() {

}

// 增加信息
public void addInformation() {

}

//更新信息
public void updateInformation() {

}

public static void main(String[] args) {
    Student student = new Student();

}

}
”’
运行结果：

我感觉学习c++的面向对象的对象构造过程跟能理解一个对象的构造深度，它里面包括了的对象的释放–析构函数，对象的释放严格与构造过程相反。