JAVA小白进阶day06

复习：

1、面向过程：关注点–>过程（步骤)
2、面向对象：关注点–>对象
类和对象：
类–>抽象
对象–>实体
3、构造方法：
定义：方法名与类名相同，没有返回类型
来源：不定义–>默认，public 无参
如果定义–>不默认构造方法了
作用：创建对象 new
调用：new + 构造方法
//注意子类的构造方法内如何调用父类或本类的构造方法，this，super
4、变量的分类：
成员变量（有默认值，整个类可使用）
局部变量（局限于方法内）

void f(int x){
	int y;
	//x可以直接使用，y未赋值不可以使用
} 

this：
表示本类对象
this.成员
this(实参列表);//构造方法的第一条有效语句
封装：变量定义private set/get方法
实现封装：private
提供get/set方法
继承：
子类可以继承父类所有成员（除构造方法）
extends
继承定义：
子类父类：
单一继承：

class A{
	void f(){}
}
class B{
	void f(){}
}
class  C extends A{//Java单一继承
}
Object obj = new Integer();
子 is a 父

super：
父类的对象
若子类有同名，先用子类，若需掉用父类，用super
super.成员
super(参数列表)

※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※

1、访问修饰符
private 可修饰变量、方法，不能修饰类，本类可访问
默认default 可修饰类、变量、方法，本包可访问
protected 可修饰变量、方法，不能修饰类，
同一包,不同包（需要继承关系的类）可访问
public 可修饰变量、方法、类，全部可访问
2、方法重写
继承关系
父类和子类：方法名相同，参数列表相同，
方法的返回类型相同
（如果是继承关系，重写方法子类的方法类型<=父类）
子类方法的访问修饰符 >= 父类
异常：子类方法的异常(非运行时异常) <= 父类
为什么要重写？扩展父类方法的功能
私有方法不能被重写
3、继承关系中构造方法的调用规则
1》子类创建对象时总是默认调用父类无参的构造方法
2》如果父类没有无参的构造方法，使用super()调用指定的构造方法

class A{
	int x;
	int y;
	public A(int x,int y){
		System.out.println("A");
	}
}
class B extends A{
	public B(int x, int y){
		super(x, y);//加这句话后可以正常使用
		System.out.println("B");
	}
}
B b = new B(1,2);//自动总是自动调用父类的无参构造方法

4、多态
定义：一种类型的变量可以指向不同的对象
编译时的多态：方法的重载

	class A{
		void f(){
			System.out.println("f");
		}
		void f(int x){
			System.out.println("f"+x);
		}
	}
	A a1 = new A();
	A a2 = new A();
	a1.f();
	a2.f(1);

运行时的多态：方法的重写
 在Animal类中定义eat方法，Dog和Bird类中重写
Animal a1 = new Dog();
Animal a2 = new Biard();
a1.eat();
a2.eat();

在编译时，看变量的声明类型
运行时，如果子类重写了父类的方法会动态绑定到子类上，运行子类的方法
方法动态绑定，变量不动态绑定
Animal a = new Dog();//使用Animal的变量，变量跟随声明类型
//编译不看子类只看父类，♥主要看声明
1>多态的应用
父类，子类重写
2>对象造型（对象的强制转换）
instanceof

5、修饰词
static ：
1》修饰变量，方法，静态块
变量：成员–>类变量（静态变量）由static修饰的成员变量
实例变量：没有static修饰
局部
类变量和实例变量的区别：
类变量对所有变量公用的
实例变量是归对象所有，不是公用
静态变量可以有类名调用
静态变量：类加载器加载类的时候初始化的
变量的初始化过程：
static int x = 5;
2》修饰方法：
静态方法：由static修饰，不创建对象，
静态方法若要使用非静态需要对象.属性/方法
实例方法：没有static修饰
静态方法可以重写吗？ 不能重写(静态方法与对象无关)，
可以有一样的但是不是重写
重载吗？ 可以
继承吗？ 可以
构造方法是否可以定义静态的？ 不可以
静态方法是否可以使用this，super 不能，对象的创建晚于静态成员的创建
3》静态块
static{}
写道类体里，在类加载时，执行一次，
分配内存–>找静态块–>顺序执行

public class A{
	static int x = 9;
	static{
		x = 10;
		y = 20;
		z = 30;
	}
	int y = 50;
	int z;
}
结果： x = 10; y = 50; z = 30;

public class Test{
	private static Test tester = new Test();     //步骤1
	private static int count1;		//步骤2
	private static int count2 = 2;		//步骤3
	public Test(){
		count1++;
		count2++;
		System.out.println(""+count1+"，"+count2);
		//输出结果1，1
		//实现步骤：先给count1、count2分配空间，默认值0
		//	开始顺序执行，
		//	首先执行步骤1，
		//	     test（）给count1，count2分别加1
		//	输出 1，1
	}
	public static Test getTester(){
		//            下一步顺序执行
		//	执行步骤2，3，count1，count2值变为1，2
		System.out.println(""+count1+"，"+count2);
		//输出1，2
		return tester;
	}
	public  static void main(String[] args){
		Test.getTester();
	}
}
	输出结果：1，1
		 1，2

4》静态块和构造块
	父类的静态块-->子类的静态块-->父类的构造块
	       -->父类的构造方法-->子类的构造块-->子类的构造方法

final
final可以修饰类，方法，变量
final修饰的变量：常量
常量名：一般名字的所有字母都大写，单词间用下划线
格式：final int PRICE = 100;
特点：不能改
可先声明，但在构造方法中必须都先赋值
可修饰局部变量
final修饰的方法：不能重写，可以被继承
final修饰类：不能被继承