java知识day09(代码块;继承;关键词super和this)

代码块

在Java中使用，{}包起来的内容，称为代码块

代码块分为：

局部代码块

在类中的局部位置（方法中定义）
作用:限定当前该局部变量的生命周期,仅仅是在当前代码块作用域中有效

构造代码块

在类中的成员位置使用{}定义,每次执行构造方法之前,先执行构造代码块如果有构造代码块
作用:可以将多个构造方法中的相同的代码可以放到构造代码块中,给对象进行初始化!

静态代码块

在类中的成员位置,static{} ,特点每次只执行一次,优先于对象存在
作用:给类进行初始化的
注意实行:
静态代码块只加载一次!
优先级:
静态代码块> 构造代码块>构造方法

class Code{		//code.class只加载一次

	//静态代码块
	static{
		int x = 1000 ;
		System.out.println(x) ;  //1000
	}
	
	//构造代码块
	{
		int x = 100 ; 
		System.out.println(x) ;//100
	}
	//无参构造方法
	public Code(){
		System.out.println("code...") ;
	}
	
	//有参构造方法
	public Code(String name){
		System.out.println(name); 
	}
	
	//构造代码块
	{
		int y = 200 ;
		System.out.println(y) ; //200
	}
	
	//静态代码块
	static{
		int y = 2000 ;
		System.out.println(y) ; 
	}
	
}

//测试类
class CodeTest{
	
	public static void main(String[] args){
		
		//局部代码块
		{
			int x  = 10 ;
			System.out.println(x) ;//10
		}
		{
			int y  = 20 ;
			System.out.println(y) ;//20
		}
		
		//创建Code类对象
		Code code = new Code();	
		System.out.println("---------------------") ;
		Code code2 = new Code("高圆圆");
	}
}

继承

继承的概念:

将多个类中的共同代码单独提取出来,形成一个独立的类,
多个类和当前独立的类产生一种关系: 继承关系 extends

继承的好处:

1)提高了代码的复用性
2)提高了代码维护性
3)类和类产生这种关系,是多态的前提条件!

Java中的开发原则: Java的所有原则以及Java 23种设计模式,都需要遵循低耦合,高内聚

低耦合,高内聚 (降低耦合性,提高内聚性)
耦合:指的是类和类产生的关系(关系越少越好),一旦一个类中有问题了 ,其他类可能都会受牵连!
内聚:完成一件事情的能力(一个类中如果能完成,尽量一个类完成)

关键字: extends

Java中继承的特点:

1)在Java中,只支持单继承,不支持多继承,在别的语言可能有多继承存在
多继承的语言:class 子类名 extends 父类名1,父类名2{}
2)在Java中,虽然不支持多继承,但是可以多层继承! (分层初始化:先让父类初始化再是子类初始化)
在Java中,所有的Java类(自己定义的,Jdk提供的)都继承自 Object类 (上帝)

继承中的注意事项:

1)子类继承父类,只能继承父类非私有的成员(成员变量,成员方法),但是可以通过公共方法间接的访问!
2)子类不能继承父类的构造方法,但是可以通过关键字
间接访问父类的构造方法(等会讲super)
3)不要为了部分使用功能去使用"继承"

继承中:

成员的组成

成员变量
构造方法
成员方法

成员变量

1)子类继承父类,子类中的成员变量名称和父类中的成员变量不一致的情况:比较简单,分别输出!
2)子类继承父类,子类中的成员变量名称和父类中的成员名称一致的情况:(重点)
a)先在子类的局部位置中找,如果存在,就使用
b)如果在类的局部位置没有,那么在子类的成员位置找,如果存在,就使用
c)如果子类的成员位置没有,那么在父类的成员位置找,如果存在,就使用
d)如果父类的成员位置都没有,那么就报错!

this和super的使用

访问成员变量
this.成员变量:访问的当前类的成员变量
super.成员变量:访问的父类的成员变量
访问构造方法:
this()/this(…):访问本类中构造方法
super()/super(…):访问父类中的构造方法
访问成员方法
this.成员方法名():访问本类中的成员方法
super.成员方法名():访问父类中的成员方法

继承中构造方法初始化的特点(分层初始化!)

继承中,子类不能继承父类的构造方法,但是可以通过super访问父类的构造方法
子类的构造方法中(无参/有参),都会默认访问父类的无参构造方法,
由于子类继承父类,子类可能会用到父类中数据,
所以先让父类进行初始化,再让子类初始化!(分层初始化!)
关于super():访问无参构造方法,必须写在子类构造方法中第一句话

继承中使用构造方法的注意事项:

需求:子类继承父类的时候,子类的构造方法都会默认访问父类的无参,如果父类中不存在无参构造
会出现什么现象?
编译报错
如何解决?
1)手动显示的给出父类的无参构造方法
2)如果父类的无参构造方法不给出,只能通过super(…)间接的访问父类的有参构造
3)可以在子类有参构造方法中通过this(),访问本类的无参,然后在通过本类的无参间接的
通过super(…)访问父类的有参

记住一句话:
子类有参构造或者无参构造的一个,必须让父类进行初始化!

继承使用例子:猫.狗继承动物

class Animals{
	private String name;
	private int age;
	private String maose;
	public Animals(){
	}
	public Animals(String name,int age,String maose){
		this.name=name;
		this.age=age;
		this.maose=maose;
	}
	public void setname(String name){
		this.name=name;
	}
	public void setage(int age){
		this.age=age;
	}
	public void setmaose(String maose){
		this.maose=maose;
	}
	public String getname(){
		return name;
	}
	public int getage(){
		return age;
	}
	public String getmaose(){
		return maose;
	}
	public void eat(){
		System.out.println("正在吃饭...");
	}
	public void sleep(){
		System.out.println("正在睡觉...");
	}
}
class Dog extends Animals{
	public Dog(){
	}
	public void xingge(){
		System.out.println("温顺") ;
	}
}
class Cat extends Animals{
	public Cat(){
	}
	public void xingge(){
		System.out.println("暴躁") ;
	}
}
class DogCat{
	public static void main(String[] args){
		Dog d=new Dog();
		d.setname("金毛");
		d.setage(2);
		d.setmaose("金色");
		System.out.println(d.getname()+"--"+d.getage()+"岁--"+d.getmaose());
		d.sleep();
		d.eat();
		Cat c=new Cat();
		System.out.println("--------------------------") ;
		c.setname("大橘为重");
		c.setage(3);
		c.setmaose("橘黄色");
		System.out.println(d.getname()+"--"+d.getage()+"岁--"+d.getmaose());
		c.eat();
		c.sleep();
	}
}