面向对象

局部变量和成员变量区别

区别一：定义的位置不同

定义在类中的变量是成员变量

定义在方法中或者{}语句里面的变量是局部变量

区别二：在内存中的位置不同

成员变量存储在对内存的对象中

局部变量存储在栈内存的方法中

区别三：声明周期不同

成员变量随着对象的出现而出现在堆中，随着对象的消失而从堆中消失

局部变量随着方法的运行而出现在栈中，随着方法的弹栈而消失

区别四：初始化不同

成员变量因为在堆内存中，所有默认的初始化值

局部变量没有默认的初始化值，必须手动的给其赋值才可以使用。

基本类型和引用类型作为参数传递

class Demo{public static void main(String[] args){int x = 4;show(x);System.out.println("x="+x);}public static void show(int x){x = 5;}}

基本类型作为参数传递时，其实就是将基本类型变量x空间中的值复制了一份传递给调用的方法show()，当在show()方法中x接受到了复制的值，再在show()方法中对x变量进行操作，这时只会影响到show中的x。当show方法执行完成，弹栈后，程序又回到main方法执行，main方法中的x值还是原来的值。

class Demo {int x ;public static void main(String[] args) {Demo d = new Demo();d.x = 5;show(d);System.out.println("x="+d.x);}public static void show(Demo d){d.x = 6;}}

当引用变量作为参数传递时，这时其实是将引用变量空间中的内存地址(引用)复制了一份传递给了show方法的d引用变量。这时会有两个引用同时指向堆中的同一个对象。当执行show方法中的d.x=6时，会根据d所持有的引用找到堆中的对象，并将其x属性的值改为6.show方法弹栈。

由于是两个引用指向同一个对象，不管是哪一个引用改变了引用的所指向的对象的中的值，其他引用再次使用都是改变后的值。

 封装表现：

 1、方法就是一个最基本封装体。

l2、类其实也是一个封装体。

 从以上两点得出结论，封装的好处：

 1、提高了代码的复用性。

 2、隐藏了实现细节，还要对外提供可以访问的方式。便于调用者的使用。这是核心之一，也可以理解为就是封装的概念。

 3、提高了安全性。

   内存的理解:

class Person {private int age;public int getAge() {return this.age;}public void setAge(int age) {this.age = age;}}

----------------------------------------------------------------------------------------------------------------------------------------------------------

public class PersonDemo {public static void main(String[] args) {Person p = new Person();p.setAge(30);System.out.println("大家好，今年我" + p.getAge() + "岁");}}

程序执行流程说明：
1、先执行main方法（压栈），执行其中的 Person p = new Person()；
2、在堆内存中开辟空间，并为其分配内存地址0x1234，紧接着成员变量默认初始化(age = 0)；将内存地址0x1234赋值给栈内中的Person p 变量
3、继续执行p.setAge(30)语句，这时会调用setAge(int age)方法，将30赋值为setAge方法中的“age”变量；执行this.age = age语句，将age变量值30 赋值给成员变量this.age为30；
4、setAge()方法执行完毕后（弹栈），回到main()方法，执行输出语句System.out.println()，控制台打印p对象中的age年龄值。

l private关键字，私有的意思

l 它可以用来修饰类中的成员(成员变量，成员方法)

l private的特点：

l private修饰的成员只能在当前类中访问，其他类中无法直接访问

this关键字
this关键字，本类对象的引用
this是在方法中使用的，哪个对象调用了该方法，那么，this就代表调用该方法的对象引用
this什么时候存在的？当创建对象的时候，this存在的
this的作用：用来区别同名的成员变量与局部变量（this.成员变量）

class Fu{//Fu中的成员变量。int num = 5;}class Zi extends Fu{//Zi中的成员变量int num2 = 6;//Zi中的成员方法public void show(){//访问父类中的numSystem.out.println("Fu num="+num);//访问子类中的num2System.out.println("Zi num2="+num2);}}class Demo {public static void main(String[] args) {Zi z = new Zi(); //创建子类对象z.show(); //调用子类中的show方法}}

class Fu{//Fu中的成员变量。int num = 5;}class Zi extends Fu{//Zi中的成员变量int num = 6;void show(){//子父类中出现了同名的成员变量时//在子类中需要访问父类中非私有成员变量时，需要使用super关键字//访问父类中的numSystem.out.println("Fu num="+super.num);//访问子类中的num2System.out.println("Zi num2="+this.num);}}class Demo5 {public static void main(String[] args) {Zi z = new Zi(); //创建子类对象z.show(); //调用子类中的show方法}}

Fu类中的成员变量是非私有的，子类中可以直接访问，若Fu类中的成员变量私有了，子类是不能直接访问的。

 当子父类中出现了同名成员变量时，在子类中若要访问父类中的成员变量，必须使用关键字super来完成。super用来表示当前对象中包含的父类对象空间的引用。

方法重写的注意事项

l 子类方法覆盖父类方法，必须要保证权限大于等于父类权限。

class Fu(){void show(){}    public void method(){}}class Zi() extends Fu{public void show(){}  //编译运行没问题    void method(){}      //编译错误}

l 写法上稍微注意:必须一模一样:函数的返回值类型 函数名 参数列表都要一样。

总结：当一个类是另一个类中的一种时，可以通过继承，来继承属性与功能。如果父类具备的功能内容需要子类特殊定义时，进行方法重写

抽象类的特点：

1、抽象类和抽象方法都需要被abstract修饰。抽象方法一定要定义在抽象类中。

2、抽象类不可以直接创建对象，原因：调用抽象方法没有意义。

3、只有覆盖了抽象类中所有的抽象方法后，其子类才可以创建对象。否则该子类还是一个抽象类。

1、抽象类一定是个父类？

是的，因为不断抽取而来的。

2、抽象类中是否可以不定义抽象方法。

是可以的，那这个抽象类的存在到底有什么意义呢？仅仅是不让该类创建对象。

3、抽象关键字abstract不可以和哪些关键字共存？

1、private：私有的方法子类是无法继承到的，也不存在覆盖，而abstract和private一起使用修饰方法，abstract既要子类去实现这个方法，而private修饰子类根本无法得到父类这个方法。互相矛盾。

2、final，static