Java基础学习笔记09——（final关键字，多态，抽象类，接口）-优快云博客

本文链接：https://blog.youkuaiyun.com/liuganzhuihui/article/details/78343008

1：final关键字（掌握）

（1）是最终的意思，可以修饰类，方法，变量。

（2）特点：

           A：它修饰的类，不能被继承。
           B：它修饰的方法，不能被重写。
           C：它修饰的变量，是一个常量。

（3）面试相关：

		   A：局部变量
		     a：基本类型 值不能发生改变
		     b：引用类型 地址值不能发生改变，但是对象的内容是可以改变的
		   B：初始化时机
			 a：只能初始化一次
			 b：常见的赋值
				 定义的时候。（推荐）
				 在构造方法中

2：多态（掌握）

（1）同一个对象在不同时刻体现出不同的状态

（2）多态的前提：

		A：有继承或者实现关系
		B：有方法重写
		C：有父类或者父接口引用指向子类对象
		
	    多态的分类：
		    a：具体类多态
			    class Fu{}
			    class Zi extends Fu{}
			    Fu f = new Zi();
			b：抽象类多态
				abstract class Fu {}
				class Zi extends Fu {}
			c：接口多态
				interface Fu {}
				class Zi implements Fu {}

				Fu f = new Zi();

（3）多态中的成员访问特点

		A：成员变量——编译看左边，运行看左边
		B：构造方法——子类的构造都会默认访问父类构造
		C：成员方法——编译看左边，运行看右边
		D：静态方法——编译看左边，运行看左边
	原因：因为成员方法有重写

（4）多态的好处

		A：提高代码的维护性（继承体现）
		B：提高代码的扩展性（多态体现）

（5）多态的弊端

		父不能使用子的特有功能
		现象：子可以当作父使用，父不能当作子使用。

（6）多态的转型

		A：向上转型——从子到父
		B：向下转型——从父到子

（7）多态的练习

		A：猫狗案例
		B：老师和学生案例

3：抽象类（掌握）

（1）把多个共性的东西提取到一个类中，这是继承的做法。但会出现方法声明一样，每个具体的对象在具体实现的时候内容不一样。所以，我们在定义这些共性的方法时候，就不能给具体的方法体。而一个没有具体方法体的方法是抽象的方法。在一个类中如果有抽象方法，该类必须定义为抽象类。
（2）抽象类的特点
	A：抽象类和抽象方法必须用关键字 abstract 修饰
	B：抽象类中不一定有抽象方法，但是有抽象方法的类一定是抽象类
	C：抽象类不能实例化
	D：抽象类的子类
		a：是一个抽象类
		b：是一个具体类。这个类必须重写抽象类中的所有抽象方法。
（3）抽象类的成员特点：
	A：成员变量——有变量，有常量
	B：构造方法——有构造方法
	C：成员方法——有抽象，有非抽象
（4）抽象类的练习
	A：猫狗案例练习
	B：老师案例练习
	C：学生案例练习
	D：员工案例练习
（5）抽象类的几个小问题
	A：抽象类有构造方法，不能实例化，构造方法的作用是用于子类访问父类数据的初始化
	B：一个类如果没有抽象方法，却定义为抽象类是为了不让创建对象
	C：abstract 不能和哪些关键字共存
		a：final 冲突
		b：private 冲突
		c：static 无意义

4：接口（掌握）

（1）回顾猫狗案例，它们仅仅提供一些基本功能。比如：猫钻火圈，狗跳高等功能，不是动物本身就具备的，是在后面的培养中训练出来的，这种额外的功能，java提供了接口表示。
（2）接口的特点：
	A：接口用关键字interface修饰    interface 接口名 {}
	B：类实现接口用implements修饰    implements 接口名 {}
	C：接口不能实例化
	D：接口的实现类
		a：是一个抽象类
		b：是一个具体类，这个类必须重写接口中的所有抽象方法。
（3）接口的成员特点：
	A：成员变量——只能是常量，默认修饰符：public static final
	B：构造方法——没有够着方法
	C：成员方法——只能是抽象的，默认修饰符：public abstract
（4）类与类，类与接口，接口与接口
	A：类与类——继承关系，只能单继承，可以多层继承
	B：类与接口——实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时，实现多个接口
	C：接口与接口——继承关系，可以单继承，也可以多继承
（5）抽象类和接口的区别
	A：成员区别
		抽象类：成员变量——可以是变量，也可以是常量
			  构造方法——有
			  成员方法——可以抽象看，也可以非抽象
		接口：成员变量——只能是常量
		     成员方法——只能是抽象
    B：关系区别：
	    类与类：继承关系，单继承
	    类与接口：实现，多实现
	    接口与接口：继承，单继承，多继承
	C：设计理念不同
		抽象类被继承体现的是：“is a”的关系，抽象类中定义的是该继承体系的共性功能
		接口被实现体现的是：“like a”的关系，接口中定义的是该继承体系的扩展功能
（6）练习：
	A：猫狗案例，加入跳高功能
	B：老师和学生案例，加入抽烟功能

附：

/*
老师和学生案例，加入抽烟的额外功能

分析：从具体到抽象
	老师：姓名，年龄，吃饭，睡觉
	学生：姓名，年龄，吃饭，睡觉
	
	由于有共性功能，我们提取出一个父类，人类。
	人类：
		姓名，年龄
		吃饭();
		睡觉(){}
	
	抽烟的额外功能不是人或者老师，也不是学生一开始就应该具备的，所以，我们把它定义为接口
	
	抽烟接口。
	
	部分老师抽烟：实现抽烟接口
	部分学生抽烟：实现抽烟接口
	
实现：
	从抽象到具体
	
使用：具体

//定义抽烟接口

	interface Smoking {
		//抽烟的抽象方法
		public abstract void smoke();
	}

//定义抽象人类

	abstract class Person {
		//姓名
		private String name;
		//年龄
		private int age;
	
		public Person() {}
	
		public Person(String name,int age) {
			this.name = name;
			this.age = age;
		}
	
		public String getName() {
			return name;
		}
	
		public void setName(String name) {
			this.name = name;
		}
	
		public int getAge() {
			return age;
		}
	
		public void setAge(int age) {
			this.age = age;
		}
	
		//吃饭（）;
		public abstract void eat();
	
		//睡觉（）{}
		public void sleep() {
		System.out.println("睡觉觉了");
		}
	}

//具体老师类

	class Teacher extends Person {
		public Teacher() {}
	
		public Teacher(String name,int age) {
			super(name,age);
		}
	
		public void eat() {
			System.out.println("吃大白菜");
		}
	}

//具体学生类

	class Student extends Person {
		public Student() {}
		public Student(String name,int age) {
		super(name,age);
		}
	
		public void eat() {
			System.out.println("吃红烧肉");
		}
	}

//抽烟的老师

	class SmokingTeacher extends Teacher implements Smoking {
		public SmokingTeacher() {}
	
		public SmokingTeacher(String name,int age) {
			super(name,age);
		}
	
		public void smoke() {
			System.out.println("抽烟的老师");
		}
	}

//抽烟的学生
	
	class SmokingStudent extends Student implements Smoking {
			public SmokingStudent() {}
	
			public SmokingStudent(String name,int age) {
			super(name,age);
		}
	
			public void smoke() {
				System.out.println("抽烟的学生");
		}
	}

//测试类

	class InterfaceTest2 {
		public static void main(String[] args) {
		//测试抽烟学生
		SmokingStudent ss = new SmokingStudent();
		ss.setName("林青霞");
		ss.setAge(27);
		System.out.println(ss.getName()+"---"+ss.getAge());
		ss.eat();
		ss.sleep();
		ss.smoke();
		System.out.println("------------------------");
		
		//测试抽烟老师
		SmokingTeacher st = new SmokingTeacher("刘意",30);
		System.out.println(st.getName()+"---"+st.getAge());
		st.eat();
		st.sleep();
		st.smoke();
	}