JAVA总结 DAY09 1024

DAY09

一、继承

1.继承的概述
1、让类与类产生关系，子父类的关系
2、关键字：extends，扩展、增加、继承
3、父类和子类：
父类：被继承的类，超类、基类
子类：用于继承的类，派生类
4、生活中的继承
①子继承父的财产 ②徒弟继承师父技术
与开发中的基层不是完全一样 开发中的继承其实有一个共性点:共性的抽取
代码示例

public static void main(String[] args) {
		//有继承
		Cat c = new Cat();
		c.sleep();
		System.out.println(c.getColor());
	}

}
class Animal {
	String color;
	int age;
	{
		color = "red";
		age = 2;
	}
	public void sleep(){
		System.out.println("睡觉");
	}
	public void eat(){
		System.out.println("吃");
	}
}

class Cat extends Animal{//通过extends让类与类之间产生联系
}

2.继承中成员变量的关系

1、在子父类中定义了不同名称的成员变量，在子类中，既可以访问子类的成员变量，也可以访问父类的成员变量。
2、在子父类中定义了同名的成员变量，在子类中，根据就近原则来访问
在子类的方法中，如果访问了某个变量名称，优先在当前方法中，寻找该变量的定义，如果找到了就使用方法中的局部变量；如果没有找到，就到子类的成员位置寻找该变量的定义，如果找到了就使用子类的成员变量；如果没有找到，就到父类的成员位置寻找该变量的定义…一直往上找，一直到Object类中，如果还没有找到，就编译报错。

	public static void main(String[] args) {
		//成员变量的关系
		Zi z = new Zi();
		z.test(1000);
		System.out.println(z.a);
		System.out.println(z.b);//子类继承了父类的属性，所以能够访问
		Fu f = new Fu();
		System.out.println(f.a);
		//System.out.println(f.c);//int c 是子类中特有的属性，父类中没有定义，所以父类的对象就不能访问子类的属性
	}
	
class Fu {
	int a = 10;
	int b = 20;
}
class Zi extends Fu {
	int a = 100;
	int c = 50;
	public void test(int a){//如果访问了某个变量名称，优先在当前方法中，寻找该变量的定义，
		System.out.println(a);
	}
	public void test_1(){
		//System.out.println(d);d既没有在子类定义，也没有在父类中定义
	}
}	

3.this和super的使用

1、 this关键字表示本类当前对象的引用
哪个对象在调用this所在的方法，this就表示哪个对象
super关键字表示本类当前对象的父类的引用
哪个对象在调用super所在的方法，super就表示哪个对象中的父类部分的数据
2、super和this都可以访问成员变量
super只能访问父类中定义的成员变量
super.成员变量名
this既可以访问子类中定义的成员变量，也可以访问父类中定义的成员变量
this.成员变量名
3、super和this都可以访问成员方法
super只能访问父类中定义的成员方法
super.成员方法名()
this不仅可以访问子类中定义的成员方法，也可以访问父类中定义的成员方法
this.成员方法名()
4、super和this都可以访问构造方法：this语句和super语句
this()：访问本类的其他构造方法
super()：访问父类的构造方法
代码示例

	public static void main(String[] args) {
		//this 和super 的使用
		Zi z = new Zi();
		z.test_1(1000);
	}
class Fu {
	int i = 10;
	int j = 20;

	public void test(){
		System.out.println("我是父类中的方法");
	}
}
class Zi extends Fu {
	int j = 30;
	int k = 40;
	public void test_1(int i){
		System.out.println(i);
		//this可以访问子类中的成员变量，也可以访问父类中的成员变量
		System.out.println(this.i);
		System.out.println(this.j);
		//super 只能访问父类中的成员变量
		//System.out.println(super.k); 
		System.out.println(super.j);
		this.test();
		//super只能访问父类中的方法，不能访问子类中的方法
		super.test();
		//super.test_2();
	}	
	public void test_2(){
		System.out.println("我是子类中的方法");
	}
}

4.继承重构造方法的关系
1.如果在子类的构造方法中，手动增加了访问父类或者本类的构造方法，那么系统将不给你增加任何构造方法的访问
2.子类的构造方法，一定要先访问父类的构造方法
3.this()语句和super()语句必须在构造方法的第一行
super语句在第一句是为了保证父类的构造方法必须先执行
this语句在第一句是因为间接的访问了super，super必须先执行
代码示例

	public static void main(String[] args) {
		//构造方法中的关系
		Zi z = new Zi();
		System.out.println("-----------------");
		Zi z1 = new Zi(4,56);
	}

class Fu {
	int i = 10;
	int j = 20;
	public Fu(){
		System.out.println("父类的空参构造执行了");
	}
	public Fu(int i){
		this.i = i;
		System.out.println("父类的有参构造执行了");
	}

}
class Zi extends Fu{
	int j = 30 ;
	int k = 40;
	public Zi(){
		//this();//不能写递归调用
		//super(4);//调用父类的有参构造，如果不调用，默认系统给我们调用super()空参构造
		//this(5,9);
		System.out.println("子类的空参构造执行了");
	}

	public Zi(int j , int  k){
		super();//this(),super()不能共存的，而且必须把this()或者super() 放在第一句
		this.j = j;
		this.k = k;
		System.out.println("子类的有参构造执行了");
	}
}

5.继承中成员方法的关系
1.方法的重载：在同一个类中，方法名相同，参数列表不同，与返回值类型无关
2.方法的重写：在子父类中，方法名相同，参数列表相同，与返回值类型有关（相同）
别名：Override，覆写、覆盖
3.方法重写的检查：
@Override
让编译器帮助我们检查，当前的这个方法，究竟是否是对父类方法的重写。
4.方法本身还是属于父类，只是在子类中重新实现了这个方法的内容
代码示例

	public static void main(String[] args) {
		//继承中成员方法的关系
		Zi z = new Zi();
		z.test_2();
		z.test_1();
		Zi2  zz = new Zi2();
		zz.test_1();
	}

class Fu {
	int i = 10;
	int j = 20;
	public void test_1(){
		System.out.println("父类中的test_1方法");
	}
}

class Zi extends Fu {
	int k = 20;
	public Zi(){
	}
	public Zi(int k ){
	}
	public void test_2(){
		System.out.println("子类中的test_2方法");
	}
	@Override //使用此注解实现重写的检查
	public void test_1(){
		int i = 10;
		System.out.println(i+10);
	}
}

**注意事项
1.私有的方法不能被重写
2.方法重写时，子类应该是越来越强大，功能越来越多

6.继承的特点
1.java 支持单继承 也就是只能存在一个直接爸爸
一个子类只能继承一个父类（一个孩子只能有一个亲爹）
2.java支持多层继承
A类可以继承B类，B类可以继承C类，A类中拥有B、C类中的所有属性和方法
3.一个父类可以存在多个子类

7.继承的好处和弊端
1、好处：
提高了代码的复用性
提高了代码的可维护性
是多态的前提
2、弊端：
使类与类之间的联系度更高,如果该父类,子类也会发生变化(提高了代码的耦合性)
耦合性：事物与事物之间的依赖关系，互相影响的程度

二、代码块

也就是用一对大括号{}这种就称为代码块 代码块按照位置 访问修饰符 分为四大类
1.局部代码块
2. 构造代码块
3.静态代码块
4. 同步代码块
1.局部代码块
①位置: 是在方法里
②作用:在局部代码的变量的生命周期比较短,节省内存资源
③注意点:局部代码块申明的变量,出了这个代码块之后就不能获取了 (比较少用)
代码示例

	public static void main(String[] args) {
		//局部代码块
		//格式就是在方法中用{}括起来的代码
		int i = 10;
		{
			i = 20;
			//System.out.println(i);	
			int j = 10;
			j = 20;
			System.out.println("j="+ j);
		}
		System.out.println("i="+i);
		//System.out.println("j="+j);不能访问j
	}
}

2.构造代码块
①位置: 在类里,在方法外
②作用: 用于给成员变量来进行赋值,或者是每个构造方法都要执行的方法,写在这里
③构造代码块是由jvm执行的 ，只要实例化对象就会走构造代码块，构造代码块是在构造之前执行
代码示例

public static void main(String[] args) {
		Person p = new Person();
		p.show();
		Person p1 = new Person("李四",234);
		p1.show();
	}

class Person {
	private String name;
	private int age;
	private long createTime;
	//构造代码块
	{
		System.out.println("我是构造代码块");
		name = "张三" ;
		age = 14;
		createTime = System.currentTimeMillis();
	}

	public Person(){
		System.out.println("我是空参构造");
	}
}

3.静态代码块
①位置:在类里,在方法外
②作用 1.给静态变量赋值 2.加载配置文件 加载驱动
③语法: static{}
④描述: 1.静态代码块是随着类的加载而加载 2.静态代码只走一次 3.静态代码块优先加载
代码示例

class Person {
	private String name;
	private int age;
	private long createTime;
	static{
		System.out.println("我是静态代码块");
	}
	//构造代码块
	{
		System.out.println("我是构造代码块");
		createTime = System.currentTimeMillis();
	}
	public Person(){
		System.out.println("我是空参构造");//5
	}
	public Person(String name,int age){
		System.out.println("我是有参构造");//7
		this.name = name;
		this.age = age;
	}

4.同步代码块
synchronized (){} 作用:保证多线程安全

三、final关键字

1、单词含义：最终的，最后的，表示不能再改变的。
2、final关键字：可以修饰类、方法、变量
3、修饰类：
表示一个最终类，表示不能有子类，【不能被其他类继承】
一旦一个类型不能被继承，那么其中所有的方法都不能被重写
不影响当前类的方法被调用
4、修饰方法：
表示一个最终方法，【该方法不能被重写】
5、修饰变量：
表示一个最终变量，该【变量变成了常量】，就只能赋值一次
当前项目中，常用的常量一般都定义在一个类的成员位置，甚至专门定义一个常量类
定义常量的好处：见名知意，容易理解；可维护性高