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++的面向对象的对象构造过程跟能理解一个对象的构造深度，它里面包括了的对象的释放–析构函数，对象的释放严格与构造过程相反。