Java 进阶学习笔记day_01（匿名对象、抽象类）

匿名对象

---

• 匿名对象就是指没有名字的对象 (只能使用一次)

	// 有对象接收
	Student stu = new Student();

	// 没有对象接收
	new Student();
	

继承_

• 继承的格式

	
	修饰符 class 子类名 extends 父类名{

}

示例：

	
	// 父类
	public class Person{
		String name = "张三";
		int age = 66;

		public void eat(){
			System.out.println("父类吃饭");
	}
	 	public void sleep(){
	 		System.out.println("父类睡觉");
	}
}

	
	// 子类继承父类
	public class Student extends Person{
	
}

	public class Demo{
		public static void main(String args[]){
			// 定义子类对象去访问父类成员变量和方法
			Studnet stu = new Student();
			System.out.println(stu.name): // 输出 张三
			System.out.println(stu.age); // 输出 66
			System.out.println(stu.eat()): // 输出 父类吃饭
			System.out.println(stu.sleep()): // 输出 父类睡觉
	}
}

一个父类可以有多个子类，但一个子类不能有多个父类

方法重写_

• 类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同）,该方法就是重写的方法
• 子类中调用和父类一模一样的方法时，会优先在子类调用

示例：

	class Fu{
		 public void func(){
        System.out.println("Fu func...");
    }
}

class Zi extends Fu{
    // 重写的func方法
    public void func(){
        System.out.println("Zi func...");
    }
}

public class Test {
    public static void main(String[] args) {
      	new Zi().func(); // 输出 Zi func...
    }
}

	class Fu{
		public void func(){
        System.out.println("Fu func...");
    }
}

class Zi extends Fu{
    // 重写的func方法
    //public void func(){
    //    System.out.println("Zi func...");
    //}
}

public class Test {
    public static void main(String[] args) {
      	new Zi().func(); // 输出 Fu func...
    }
}

方法重写是发生在父子类之间的关系
子类方法重写父类方法，返回值类型、方法名和参数列表都要一模一样
父类的方法,子类有不同的实现,那么子类就需要重写父类的该方法
子类方法重写父类方法，必须要保证权限大于等于父类权限 (访问权限从大到小: public > protected > (默认) > private)
使用@Override注解，检验是否重写成功，重写注解校验

this和super关键字_

• this可以访问本类的成员属性，成员方法，构造方法

示例：

	// this.成员变量
	class Test{
		int a = 10;
		
		public void Show(){
			int a = 20;
			System.out.println(a): // 输出 20
			System.out.println(this.a): // 输出 10
		}	
		
}

	
	// this.成员方法
	class Test2{
		public void show1(){
			System.out.println("show1"):
	}
	public void show2(){
			System.out.println("show2"):
	}
	public void show3(){
			System.out.println("show3"):
			// 用this调用 show1 ,show2 方法
			this.show1();
			this.show2();
	}
	
}

	// 用this() 来调用构造方法
	class Test3{
		int a;
		public Test3(){
			System.out.println("被调用的空参构造");
		}
		public Test3(int a){
			this(); // 输出 被调用的空参构造
			System.out.println("有参构造");
	}
}

super关键字_

• super可以访问父类的成员属性、成员方法、构造方法

示例：

	
	// 用super 访问父类成员
	class Fu{
		int a = 10;
	}
	class Zi extends Fu{
		System.out.println(super.a); // 输出 10
	}

	// 用super 访问父类方法
	class Fu{
		public void show(){
			System.out.println("Fu ..");
	}
}
	class Zi extends Fu{
		super.show(); // 输出 Fu ..
	}

	// 用super 访问父类构造方法
	class Fu{
	int a;
		public Fu(){
		
	}
		public Fu(int a){
			
	}
}

	class Zi extends Fu{
		public Zi(){
			super(); // 调用空参构造
	}
		public Zi(int a){
			super(12); // 调用满参构造	
	}	
		
		
}

super访问成员变量和成员方法: 优先去父类中找,如果有就直接使用,如果没有就去爷爷类中找,如果有,就用,依次类推…
Java中顶层父类是Object类,所有的类都直接或者间接继承Object类

• 子类编译报错: 子类会自动生成空参构造方法,而该空参构造方法中会默认调用父类的空参构造方法,而父类没有生成空参构造方法
• 子类的构造方法默认会调用父类的空参构造方法,如果父类中没有空参构造方法,只定义了有参构造方法,会编译报错

抽象类_

• 没有方法体,使用abstract修饰的方法就是抽象方法
• 有抽象方法的类一定是抽象类,抽象类中不一定有抽象方法
• 强制要求子类重写

	修饰符 abstract class 类名{

 }

示例：

	public abstract class Person{
		// 成员变量
		String name;
		int age;
		// 空参构造
		public Person(){
			
		}
		// 满参构造
		public Person(String name,int a){
			this.name = name;
			this.age = age;
		}
		
}

示例2：

	public abstract class Fu{
		// 抽象方法
		public abstract void eat();
		public abstract void sleep();
	}
	// 子类是普通类，但必须重写抽象父类中的所有抽象方法
	class Zi extends Fu {
		public void eat(){
		}
		public void sleep(){
		}
	}

抽象类不能被创建对象，只能用来做“父类”，被子类继承的，体现的是模板思想
抽象类不能被创建对象，但可以有“构造方法”——为从父类继承过来的属性初始化
抽象类中可以没有抽象方法,但抽象方法必须定义在抽象类中
子类继承抽象类后,必须重写抽象类中所有的抽象方法,否则子类必须也是一个抽象类

final关键字_

• jdk中被final修饰的类: String类,Scanner类,Math类…

	final class Fu{
	
	
	}
	// 被final修饰的类不能被继承
	class Zi extends Fu{
	
		// 编译报错
	}

---------------------------------------------------------------------------------------------

	 class Fu{
		public final void show(){
	
		}
	
	}
	
	// 被final修饰的类不能被重写
	class Zi extends Fu{
		public void show(){
			// 编译报错
		}
		
	}

	
	

• 修饰变量
  final 数据类型 变量名 = 值;
final 数据类型 变量名; 变量名 = 值;
• 被final修饰的变量只能赋值一次,不能重复赋值
• 一般开发中,被final修饰的变量,变量名都是全部字母大写( fianl修饰的变量其实就是自定义的常量)

	public class Demo4 {
    public static void main(String[] args) {
        // 方式一: 
        final int A = 10;
        A = 20; // 编译报错,因为final修饰的变量只能赋值一次
        
        
        // 方式二:
        final int B;
        B = 100;
        B = 200;// 编译报错,因为final修饰的变量只能赋值一次
        
    }
}