面向对象

方法

 成员变量和局部变量的区别

	1、在类中的位置不同
		成员变量：类中方法外
		局部变量：方法定义中或者方法声明上
	2、在内存中的位置不同
		成员变量：在堆中
		局部变量：在栈中
	3、生命周期不同
		成员变量：随着对象的创建而存在，随着对象的消失而消失
		局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
	4、初始化值不同
		成员变量：有默认值
		局部变量：没有默认值，必须定义，赋值，然后才能使用
	注意事项：
		局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。

案例：

class Varialbe {
    //成员变量
    int num; //默认值0
    
    public void show() {
        //可能尚未初始化变量num2
        int num2; //没有默认值
        num2 = 20; //定义后必须赋值才能使用
        
        //方法中可以使用成员变量和局部变量
        System.out.println(num2);    
        System.out.println(num);
    }
}

class VariableDemo {
    public static void main(String[] args) {
        Varialbe v = new Varialbe();
        
        System.out.println(v.num); //访问成员变量，不能访问局部变量num2
        
        v.show();    
            
    }
}

类与对象

 对象内存存储过程

 类作为形式参数(理解)

　　如果你看到一个方法需要的参数是一个类名，就应该知道这里实际需要的是一个具体的对象

 匿名对象(理解)

	1、没有名字的对象
	2、应用场景
		a、调用方法，仅仅只调用一次的时候。
		b、匿名对象调用完毕就是垃圾,可以被垃圾回收器回收。
		c、可以作为实际参数传递。
	3、例子：new Student().show();

 类的封装

	1、为了给类中的属性xxx进行赋值校验，从而产生setXxx();。(一般在这里校验)
	2、由于依然可以使用 类的对象.xxx 进行赋值，从而产生 private 类型 xxx;。（private一般赋值给成员变量）

this关键字

• • 代表当前类的引用对象

　　　　记住：哪个对象调用方法，该方法内部的this就代表那个对象

• • this的应用场景

　　　　解决了局部变量隐藏成员变量的问题

• • this关键字内存图解

static关键字

• • 静态的特点

　　　　A:随着类的加载而加载

　　　　B:被类的所有对象共享

　　　　C:静态成员变量可以通过类名调用
　　　　　　既可以通过对象名调用，也可以通过类名调用，建议通过类名调用。

• • 静态的内存图

　　　      静态的内容在方法区的静态区

• • 静态的注意事项

A:在静态方法中没有this对象

B:静态只能访问静态

 

• • main方法是静态的

public:权限最大

static:不用创建对象调用

void:返回值给jvm没有意义

main:就是一个常见的名称

String[] args:可以接收数据，提供程序的灵活性
格式：java MainDemo hello world java
java MainDemo 10 20 30

代码块(理解)

1、用{}括起来的代码。
2、分类：
	1）:局部代码块
		main函数后，用于限定变量的生命周期，及早释放，提高内存利用率。
	2）:构造代码块
		把多个构造方法中相同的代码可以放到这里，每个构造方法执行前，首先执行构造代码块。
	3）:静态代码块
		对类的数据进行初始化，仅仅只执行一次。
3、静态代码块,构造代码块,构造方法的顺序
	静态代码块 > 构造代码块 > 构造方法

继承(掌握)

	1、把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这多个类和该独立的类产生一个关系，
	   这多个类就具备了这些内容。这个关系叫继承。
	2、Java中如何表示继承呢?格式是什么呢?
		A:用关键字extends表示
		B:格式：
			class 子类名 extends 父类名 {}
	3、继承的好处：
		A:提高了代码的复用性
		B:提高了代码的维护性
		C:让类与类产生了一个关系，是多态的前提
	4、继承的弊端：
		A:让类的耦合性增强。这样某个类的改变，就会影响其他和该类相关的类。
			原则：低耦合，高内聚。
			耦合：类与类的关系
			内聚：自己完成某件事情的能力
		B:打破了封装性
	5、Java中继承的特点
		A:Java中类只支持单继承
		B:Java中可以多层(重)继承(继承体系)
	6、继承的注意事项：
		A:子类不能继承父类的私有成员
		B:子类不能继承父类的构造方法，但是可以通过super去访问
		C:不要为了部分功能而去继承
	7、什么时候使用继承呢?
		A:继承体现的是：is a的关系。
		B:采用假设法
	8、Java继承中的成员关系
		A:成员变量
			a:子类的成员变量名称和父类中的成员变量名称不一样，这个太简单
			b:子类的成员变量名称和父类中的成员变量名称一样，这个怎么访问呢?
				子类的方法访问变量的查找顺序：
					在子类方法的局部范围找，有就使用。
					在子类的成员范围找，有就使用。
					在父类的成员范围找，有就使用。
					找不到，就报错。
		B:构造方法
			a:子类的构造方法默认会去访问父类的无参构造方法
				是为了子类访问父类数据的初始化
			b:父类中如果没有无参构造方法，怎么办?
				子类通过super去明确调用带参构造
				子类通过this调用本身的其他构造，但是一定会有一个去访问了父类的构造
				让父类提供无参构造
		C:成员方法
			a:子类的成员方法和父类中的成员方法名称不一样，这个太简单
			b:子类的成员方法和父类中的成员方法名称一样，这个怎么访问呢?
				通过子类对象访问一个方法的查找顺序：
					在子类中找，有就使用
					在父类中找，有就使用
					找不到，就报错

	9、数据初始化
		A:一个类的初始化过程
			成员变量的初始化
			默认初始化
			显示初始化
			构造方法初始化
		B:子父类的构造执行过程(分层初始化)
			先进行父类初始化，然后进行子类初始化。
		D:例子：
			/*
				看程序写结果：
						
				结果：
					YXYZ
					
				问题：
					虽然子类中构造方法默认有一个super()
					初始化的时候，不是按照那个顺序进行的。
					而是按照分层初始化进行的。
					它仅仅表示要先初始化父类数据，再初始化子类数据。
			*/
			class X {
				Y b = new Y();
				X() {
					System.out.print("X");
				}
			}

			class Y {
				Y() {
					System.out.print("Y");
				}
			}

			public class Z extends X {
				Y y = new Y();
				Z() {
					//super
					System.out.print("Z");
				}
				public static void main(String[] args) {
					new Z(); 
				}
			}
	10、方法重写和方法重载的区别?方法重载能改变返回值类型吗?

			方法重写：
				在子类中，出现和父类中一模一样的方法声明的现象。
			
			方法重载：
				同一个类中，出现的方法名相同，参数列表不同的现象。


			方法重载能改变返回值类型，因为它和返回值类型无关。


			Override：方法重写
			Overload：方法重载

	11、this关键字和super关键字分别代表什么?以及他们各自的使用场景和作用。

			this:代表当前类的对象引用
			super:代表父类存储空间的标识。(可以理解为父类的引用，通过这个东西可以访问父类的成员)
	
				场景：
					成员变量：
						this.成员变量
						super.成员变量
					构造方法：
						this(...)
						super(...)
					成员方法：
						this.成员方法
						super.成员方法