JAVA学习记录day08

构造代码块和局部代码块

1,代码块就是一段代码被一对花括号包起来的现象.如: {…}
2,代码块随着位置的不同,作用和意义都不同.
3,代码块如果在成员位置(在类里方法外),叫做构造代码块.
4,代码块如果在局部位置(方法里),叫做局部代码块.
5,构造代码块------用来提取构造方法的共性
6,局部代码块------用来控制变量的作用范围
测试：

		//总结
		//1,构造代码块 -- 位置:类里方法外 -- 作用:抽取构造方法的共性
		//2,局部代码块 -- 位置:方法里 -- 作用:控制变量的作用范围
		//3,执行顺序: 构造代码块  > 局部代码块
		//4,触发时机: 
		//当创建对象时,会触发构造方法,但是,如果有构造代码块,构造代码块>构造方法
		//当方法被调用时,才触发局部代码块
		public class Test1_Block {
			public static void main(String[] args) {
				//创建Person对象测试
				new Person() ;
				new Person("jack").show() ;
			}
		}
		//创建Person类
		class Person{
			String country ;
			//1, 构造代码块---位置是在类里方法外  -- 用来抽取构造方法的共性
			//2, 在创建对象时,先触发构造代码块再触发构造方法
			{
				country = "中国人";//抽取构造方法的共性
				System.out.println("构造代码块");
			}
			//构造方法
			public Person() {
				System.out.println("无参构造"+country);
			}
			public Person(String name) {
				System.out.println("含参构造"+country);
			}	
			public void show() {
				//4,局部代码块--位置是在方法里--作用是控制变量的作用范围
				{	
					int sum = 10 ;
					System.out.println(sum);
					System.out.println("局部代码块");
				}
				//System.out.println(sum);//已经超出了sum的作用范围
			}	
		}

this关键字（代表本类对象的引用对象）

练习1：当局部变量与成员变量名相同时

        //当局部变量名和成员变量名相同时,会优先使用局部变量,
		//想要使用成员变量必须通过this调用
		public class Test2_This {
			public static void main(String[] args) {
				//TODO 创建Student对象测试
				new Student().show(); 
			}
		}
		//创建Student类
		class Student{
			int count ; //成员变量:位置在类里方法外,不用赋值也有默认值
			int sum = 20 ; 
		//1,当成员变量 和 局部变量 同名时,通过this关键字调用成员变量!
			public void show() {
				int sum = 10 ;//局部变量:位置在方法里,必须赋值
				System.out.println(sum);//就近原则,使用了局部变量10
				//TODO 如何使用成员变量sum呢?--创建一个本类的对象
		//2,this代表的是本来对象的引用,底层会自动创建本类对象Student this = new Student();
				System.out.println( this.sum );//使用了成员变量20
				System.out.println( count );//0
			}
		}

练习2：构造方法间的调用

//this -- 可以在构造方法间 实现互相调用
		public class Test3_This2 {
			public static void main(String[] args) {
				//创建对象测试
				new ThisDemo() ;
		//		new ThisDemo(10) ;
			}
		}
		//创建ThisDemo
		class ThisDemo{
			//提供构造方法
			public ThisDemo() {
				//2,在无参构造中  调用  含参构造
				this(5);//3,this关键字出现在构造方法中时,必须是第一条语句!!
				System.out.println("无参构造方法");
			}
			public ThisDemo(int a) {
				//1,在含参构造中  调用  无参构造
				//this() ;
				System.out.println("含参构造方法"+a);
			}
		}

继承

1,继承的初衷:提高代码的复用性.
2,好处:
假设没有继承结构,每种小动物都需要提供吃的功能,可能得写100万次,这个业务相同代码量非常大降低了开发效率.产生继承后,
只需要把共性的吃的功能在父类里写一次即可,哪个小动物需要提供吃,就来继承父类.
3,特点
–使用extends关键字
–相当于子类把父类的功能复制了一份
–java只支持单继承
–继承可以传递（爷爷，儿子，孙子的关系）
–不能继承父类的私有成员
–继承多用于功能的修改，子类可以拥有父类的功能的同时，进行功能拓展
–像是is a 的关系
测试：

public class Test4_Extends {
			public static void main(String[] args) {
				//TODO 创建Dog对象测试
				Dog d = new Dog();
				d.eat();//使用了父类的eat()
		//		System.out.println( d.sifangmoney );//5,父类中的private资源不能继承
				System.out.println( d.country ); //7,继承具有传递性,使用了爷爷类的功能
			}
		}
		class Yeye{
			String country = "国家保护动物";
		}
		//1,创建父类,抽取共性功能,来提高代码的复用性
		class Animal extends Yeye{
			//4,在父类中,如果不想让子类继承,可以用private修饰
			private double sifangmoney = 1000.00;
			public void eat() {
				System.out.println("吃啥都行");
			}
		}
		//2,使用extends关键字,表示继承关系--java只支持单继承
		class Dog extends Animal{
			//3,子类把父类的功能复制了一份
		}
		class Cat extends Animal{//6,像是is a的关系--强制的依赖关系
		}

super关键字

–代表的是父类对象的一个引用
–用来在子类中使用父类的功能
–如果用在构造方法中,super必须是第一条语句.
测试：

 //1,在发生了继承关系后,子类中 想要用 父类的资源 ,最好都加上super
		public class Test5_UseExtends {
			public static void main(String[] args) {
				Zi zi = new Zi();
				System.out.println( zi.skin );//1,使用了父类的skin
				zi.show(); //3,使用子类的show()
			}
		}
		class Fu{
			String skin = "yellow" ;
			int num = 30 ;//4,当父类的变量 和  子类的变量 同名时
		}
		class Zi extends Fu{
			int num = 20 ;//成员变量
			//2,子类自己扩展的功能
			public void show() {
				int num = 10 ;//局部变量
				System.out.println(num);//10,局部变量
				System.out.println(this.num);//成员变量
				System.out.println(skin);//使用父类的skin--不同名时直接用!!
				//5,在子类中,如何使用父类的num --- 通过super关键字
		//super代表父类对象的引用,相当于底层帮你创建了父类对象-- Fu super = new Fu();
				//使用父类的num--同名了,用super调用父类资源
				System.out.println( super.num );
			}
		}

继承中的构造方法

//总结
//1, 子类的构造方法中,默认就会存在super() – 去找父类的无参构造
//2, 如果父类没有提供无参构造,只提供了含参构造–只能在子类构造方法中调用父类的含参构造
//3, 提示:每个类,最好都提供一个无参构造.

public class Test7_UseExtends3 {
		public static void main(String[] args) {
			//2,当你创建了子类对象时,实际上,会先触发父类的构造方法,然后是子类的构造方法
			Erzi2 zi = new Erzi2();
		}
	}
	class Baba2{
		//4,无参构造 ,暂时不用也要提供,为了自己创建对象方便,或者为了子类.
		public Baba2() {}
		public Baba2(int a) {
			System.out.println("父类的构造方法");
		}
	}
	class Erzi2 extends Baba2{
		public Erzi2() {
	//1,子类的构造方法中,默认就会存在super()--会去找父类的无参构造
			//super();
			//3,如果父类中,没有无参构造呢? --只能调用父类的含参构造!!
			//4,super关键字,如果在构造方法中出现,位置上必须是第一条语句!!类似于this
			super(10) ;
			System.out.println("子类的构造方法");
		}
	}

方法的重写Override

– 发生在父类子间的现象
– 子类继承父类后,就可以使用父类的所有功能.
– 当子类想要修改父类原有的功能时,就会发生方法的重写/复写/覆盖
– 重写的要求 : 继承关系 + 在子类中方法的声明/签名 必须和 父类一模一样
– 方法的声明/签名 包括: 方法返回值 方法名(参数列表)

//1,子类继承了父类后
		//--可以使用父类的所有功能(除了private的)
		//--还可以进行自己特有的功能扩展
		//--继承后,如果某些功能的业务发生了改变,还可以重写
		//--重写的要求是: 子类的 方法声明 必须 和父类 一模一样
		public class Test6_UseExtends2 {
			public static void main(String[] args) {
				//创建子类对象测试
				Erzi zi = new Erzi();
				//4,在重写前,使用的是父类的吃的功能.重写后,使用了子类的功能
				zi.eat();
				zi.coding();//子类可以使用自己特有的扩展功能
			}
		}
		class Fu{
			public void eat() {
				System.out.println("爸爸在吃肉");
			}
		}
		class Erzi extends Fu{
			//1,子类可以使用父类的方法--发生了继承关系
			//2,子类可以进行功能拓展
			public void coding() {
				System.out.println("学java!");
			}
			//3,子类想要修改父类的原有功能 -- 方法重写/覆盖/复写
			//要求:子类的方法声明 必须和 父类一模一样
			public void eat() {
				//5,虽然发生了方法重写,但是,对于父类原有功能没有任何影响!!!
				//super.eat();//调用父类的功能,查看一下
				System.out.println("娃在喝汤");
			}
		}