抽象类，接口以及多态

1.抽象类

1.1抽象类声明

在Java中使用abstract修饰的类叫抽象类

在Java中使用abstract修饰的方法叫抽象方法

语法格式:

abstract class Person {

//正常类的属性
String name;
//普通的成员方法
public void eat () {
  System.out.print("吃饭");
}
//抽象方法   没有方法体的方法  没有大括号的
public abstract void sleep ();

}

abstract class Person {//抽象类
	//抽象类中可以有属性  方法  抽象方法
	
	public  void eat () {//普通方法
		System.out.println("吃饭啊");
	}
	//声明一个抽象方法  abstract  修饰符
	//是一个不完整的方法，  完整方法应该带方法体
	 public abstract void  test (int a);
	
}

//The type Man must implement(实现) the inherited abstract method Person.test()
//在普通类中 Man中，必须可以实例化的。所以Man所有的信息都要时完整的
//必须去重写 父类中 抽象的方法
class Man extends Person{
	@Override
	public void test(int a) {//是重写的 抽象的类的抽象方法
		System.out.println( a + "这个是子类重写的的抽象父类的抽象的方法");
		
	}
}
public class Demo1 {
	public static void main(String[] args) {
		//抽象类不能创建对象 咋办？ 只能 被继承
//		Person person = new Person();
		Man man = new Man();
		man.eat();
		man.test();
	}
}

3.2抽象类的详解

1.如果一个类中有抽象方法，那么这个类一定是抽象类

2.抽象方法是一个没有方法体的方法，是一个不完整的方法

3.抽象类中能有普通方法吗？ 可以

4.抽象类能被实例化吗？ 不能

5.抽象类不能被实例化，然后可以使用普通类去继承抽象类

6.在子类中 必须去重写父类的所有的抽象方法，让抽象方法变得有意义

7.在抽象类中，非抽象的方法能在子类被重写的

8.一个抽象类可以继承另外一个抽象类

9.一个抽象类也可以继承一个非抽象的类

package com.zkf.g;
abstract class Animal{
	public abstract void play();
	public abstract void eat();
	public void sleep() {
		System.out.println("睡觉");
	}
}
class Panda extends  Animal{
	@Override
	public void play() {
		System.out.println("戏水");
	}
	@Override
	public void eat() {
	System.out.println("竹笋");
	}
	@Override
	public void sleep() {
		// TODO Auto-generated method stub
		System.out.println("靠树上");
	}
}
class Cat extends Animal{

	@Override
	public void play() {
		System.out.println("老鼠");
	}

	@Override
	public void eat() {
		System.out.println("鱼");
	}
	@Override
	public void sleep() {
		// TODO Auto-generated method stub
	System.out.println("躺被窝");
	}
}
public class Dome2 {
	public static void main(String[] args) {
	Panda panda = new Panda();
	Cat cat = new Cat();
	panda.play();
	panda.eat();
	panda.sleep();
	cat.play();
	cat.eat();
	cat.sleep();
}
}

2.final关键字

字面意思 ：最终的 最后的意思 是一种修饰符

用法：

1.final可以修饰成员变量 修饰的成员变量必须初始化(赋值)，一旦赋值无法更改

2.final可以修饰局部变量 修饰局部变量可以先不赋值，使用的时候必须赋值，一旦赋值就无法更改

3.final可以修饰成员方法 修饰的方法不能被子类重写

4.final可以修饰类 修饰的类不能被继承

5.final可以修饰对象的引用 引用一旦被赋值就无法被修改

3.接口

语法格式

interface 接口的名字{
    属性
    方法
}

1.使用关键字interface来声明Java中的接口

2.接口下面是可以有属性的，只不过属性必须赋值，因为默认带了public static final 是常量

3.接口中的方法都是抽象方法，尽管没带abstract 默认也是public

4.接口下面一般都是抽象方法 jdk1.8之后出现了default修饰方法 是可以带方法体的

5.接口没有构造方法，无法实例化

6.用一个普通的类去实现（implements）接口

7.实现接口的时候一定要重写所有的抽象的方法，默认的方法可以重写也可以不写

8.一个类可以实现（implements）多个接口 implements D，C，F

9.一个接口可以去继承（extends）另外一个接口

多态

1.1多态概念

通俗的来说，就是多种形态，在java中去完成某一个行为，当不同的对象去完成的时候，会有不同的效果。

动物吃 狗吃 狗粮 猫吃猫粮

就是同一件事情，放在不同的对象上面会有不同的效果

1.2方法的多态

方法的重写和重载就叫做方法的多态

package com.qf.b_duotai;

class Person {
	public void  eat () {
		System.out.println("吃饭");
	}
    //方法的重载
    @Overload
	public void eat (String name) {
		System.out.println(name+"吃饭");
	}
}
class Man extends Person {
	//方法的重写
	@Override
	public void eat() {
		System.out.println("吃腰子");
	}
}
public class Demo1 {
	public static void main(String[] args) {
		
	}
}

1.3对象的多态

父类的引用指向了子类的对象 或者说 子类对象赋值给了父类的引用

Father father = new Son();

1.必须有继承关系

2.必须重写父类的方法

3.父类的引用就可以调用子类重写方法，不能调用子类独有的方法

package com.zkf.i;
class Animal{
	public void eat() {
		System.out.println("吃东西");
	}
	public void work() {
		System.out.println("工作");
	}
}
class Dog extends Animal{
	@Override
	public void eat() {
		System.out.println("吃大骨头");
	}
	public void sleep() {
		System.out.println("趴着睡");
	}
}
public class Dome2 {
	public static void main(String[] args) {
		Animal animal=new Dog();//父类的引用指向子类的对象
		animal.eat();//子类中重写的方法
		animal.work();//父类中的方法
		//animal.sleep();   报错 父类的引用是调用不了子类独有的方法的
	}
}

1.4多态的真实开发中应用

人 喂狗 狗吃大骨头 人 喂猫 猫吃鱼

package com.zkf.i;
/*
 * 人  喂狗 狗吃大骨头   人 喂猫 猫吃鱼
 */
class People{
	public void feed(Animals animals) {
		animals.eat();
	}
}
class Animals{
	public void eat() {
		System.out.println("吃饭");
	}
}
class Dog3 extends Animals{
	@Override
	public void eat() {
		System.out.println("吃大骨头");
	}
}
class Cat extends Animals{
	@Override
	public void eat() {
		System.out.println("吃鱼");
	}
}
public class Dome3 {
	public static void main(String[] args) {
		People people = new People();
		Animals animals =new Dog3();
		people.feed(animals);
		Animals animals2=new Cat();
		people.feed(animals2);
		
	}
}

1.5多态的转型

1.5.1多态的向上转型

就是父类的引用指向了子类的对象

语法格式：

父类  父类的引用 = new  子类();

向上转型是自动转的将子类的对象赋值 父类的引用呢 小范围（子类）转为大范围（父类）的 是可以自动转的。

父类的引用可以调用父类的所有的方法，但是不能调用子类独有的方法。最终的调用结果看的是子类中重写的方法的

1.5.2向下转型

语法格式

父类  父类的引用 = new  子类();
子类  子类的引用 = (子类) 父类的引用;   强制类型转换

1.6instanceof关键字

在Java中 instanceof 是一个二元的运算符，和> >= < <= 类似的，他的结果是true或者false

A instanceof B

目的: 测试左边的额对象 是否是右边类的实例。 注意 A 是对象 B 是类

左边的辈分 只要比 右边小或者相等 就返回值true

语法格式：

对象的引用  instanceof   类 

返回值是true或者false

Animal  父类    Dog 子类
Dog dog = new Dog();
dog instanceof  Animal   true

Animal animal = new Animal();
animal instanceof Animal  true
Animal animal1 = new Dog();
animal1  instanceof Animal  

想要向下转型，必须先向上转型

package com.qf.d_duotai;


class Animal {
	public void eat() {
		System.out.println("得吃饭");

	}
}
class Dog  extends Animal{
	@Override
	public void eat() {
		System.out.println("狗吃香肠");
	}
}
class Cat extends Animal {
	@Override
	public void eat() {
		System.out.println("猫吃老鼠");
	}
}
public class Demo2 {
	public static void main(String[] args) {
		//演示语法格式
		Animal animal = new Dog();//父类  父类的引用 = new   子类();  向上转型
		//向下转型   子类  子类的引用 = (子类) 父类的引用;
//		Dog dog1 = (Dog)animal;//强转  在强转的时候一定先向上转 然后再向下转才不会报错的
//		dog1.eat();
		
		/**
		 * ClassCastException(类转换异常): com.qf.d_duotai.Animal cannot be cast to com.qf.d_duotai.Dog
	at com.qf.d_duotai.Demo2.main(Demo2.java:32)
		 */
		这个是错误的代码
//		Animal animal2 = new Animal();
//		Dog dog2 = (Dog) animal2;
//		
		//Exception in thread "main" java.lang.ClassCastException: com.qf.d_duotai.Dog cannot be cast to com.qf.d_duotai.Cat
		//at com.qf.d_duotai.Demo2.main(Demo2.java:38)

//		Cat cat1 = (Cat)animal;
//		Dog dog1 = new Dog();
		
		
	}
}