Java基础第十课（类和接口的讲解）

咳咳，开讲。
前面我们对类和对象进行了很多的讲解，同时也讲了类的继承等知识，今天我们就来讲一下接口相关的知识。

一、抽象类

首先，什么是抽象类呢？
在类中声明一个方法，这个方法没有实现体，是一个“空”方法
这样的方法就叫抽象方法，使用修饰符“abstract"
当一个类有抽象方法的时候，该类必须被声明为抽象类

下面用代码来演示：

首先，我们先写一个抽象类AbstractDemo

package com.baidu.demo.test6;


//class前面加上一个abstract关键词则说明该类为抽象类 抽象类不能够直接被实例化 它需要被其他类继承并实现里面的方法
public abstract class AbstractDemo {
	
	//定义一个普通的变量
	int a;
	
	//这是声明的抽象方法 声明了抽象方法必须把类也改成抽象类 抽象方法里面并没有方法体
	public abstract void printName(String name);
	
	//定义一个普通的方法
	public void printAge(int age) {
		System.out.println(age);
	}
}

然后我们开始写演示类Demo1

package com.baidu.demo.test6;


public class Demo1 extends AbstractDemo {
	//继承了AbstractDemo类（也就是我们刚刚写的抽象类）就必须重写里面的抽象方法
	@Override
	public void printName(String name) {
		System.out.println(name);
	}

	public static void main(String[] args) {
		//我们的抽象类是不能被直接实例化的，但是我们可以实例化它的子类
		AbstractDemo abstractDemo = new Demo1();
		//同样我们可以调用父类AbstractDemo里面的方法
		abstractDemo.printName("张三");
		abstractDemo.printAge(11);
		//也可以使用它里面的属性
		abstractDemo.a = 1;
	}
	
}

运行结果：

二、接口

接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。
接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。
接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。
代码演示：
首先我们先创建一个接口InterfaceDemo

package com.baidu.demo.test6;

//这就是一个接口，它不像抽象类一样是在class前面加关键词，接口不属于类，所以直接用关键词Interface即可声明一个接口
public interface InterfaceDemo {
	
	//在interface里面的变量都是public static final 的  所以可以这样写:
	public static final int a=10;
	//或者可以省略掉一部分 (接口里面的变量由于加了static和final关键字，所以是不能被重新赋值的)
	int b=10;
	
	//声明一个方法  这个跟抽象方法很相似  但是接口不需要在方法上加接口关键字
	public void printName(String name);
	
	//这是JDK8的新特性，在JDK8以前的版本中，接口中是不能写带方法体的方法的
	public default void printAge(int age) {
		System.out.println(age);
	}
	
}

然后我们在创建一个测试类Demo2

package com.baidu.demo.test6;

//接口是使用implements关键字引入 而且可以引入多个接口 每个接口之间使用“,”连接
public class Demo2 implements InterfaceDemo {
	
	//重写接口
	@Override
	public void printName(String name) {
		System.out.println(name);
	}
	
	public static void main(String[] args) {
		//这里跟抽象类很相似，所以就不一一写注释了
		InterfaceDemo interfaceDemo = new Demo2();
		interfaceDemo.printName("张三");
		interfaceDemo.printAge(10);
		
		//由于接口中定义的变量是一个添加了Static和Final关键字的变量,所以是不能被重新赋值的，同时它是可以直接被InterfaceDemo访问的
		//这里我们直接用InterfaceDemo来访问变量（建议直接使用该方法访问）
		int a = InterfaceDemo.a;
		//这里是用实例化后的InterfaceDemo来访问b变量
		int b = interfaceDemo.b;
		
		System.out.println(a);
		System.out.println(b);
	}
}

运行结果：

三、super关键字

使用关键字super 可以直接调用父类的方法及属性
代码如下：
首先，我们先创建一个SuperDemo类，用来当作父类

package com.baidu.demo.test6;

public class SuperDemo {
	
	//声明一个普通的变量
	String a = "嘿嘿";
	
	//这里我们写一个无参的构造方法
	public SuperDemo() {
		System.out.println("这是无参的构造方法");
	}

	//这里我们写一个有参的构造方法
	public SuperDemo(String name){
		System.out.println(name+"调用了有参构造方法");
	}
	
	//我们写一个普通的方法
	public void printName(String name) {
		System.out.println(name);
	}
}

另外，我们再写一个测试类Demo3

package com.baidu.demo.test6;

//继承刚刚的SuperDemo父类
public class Demo3 extends SuperDemo {
	
	//子类的无参构造器
	public Demo3() {
		//使用super即可调用父类的无参构造器
		super();
	}
	
	//子类的有参构造器
	public Demo3(String name) {
		//使用super即可调用父类的有参构造器
		super(name);
	}
	
	
	//我们写一个方法
	public String a() {
		// 这里使用super访问a变量并返回
		return super.a;
	}
	
	//我们写第二个方法
	public void print(String name) {
		//这里使用super来访问父类的printName方法
		super.printName(name);
	}
	
	
	public static void main(String[] args) {
		//这里我们实例化Demo3，因为我们要测试super关键字，所以就直接实例化该子类了
		Demo3 demo3 = new Demo3();
		//调用上面的a方法，获得父类中a的值
		String r = demo3.a();
		//打印输出r
		System.out.println(r);
		
		//我们调用上面的print方法，从而调用父类中的printName方法
		demo3.print("张三");
		
		//有参构造器测试
		Demo3 d3 = new Demo3("李四");
	}
}

运行结果：

四、Final关键字

这个关键字刚刚就提到
但是怕你们不知道
还是再说一下把
Final就是最终的意思
如果这个关键字加到变量里面 这个变量将只能赋值一次就不能再被更改
如果加到方法里面 则这个方法将不能再被重写
如果加到类里面 则这个类将不能被继承
这个很简单，而且之前也用过，所以就不用具体的例子演示了
你们自己可以下来试一下
（我不会说其实就是因为我懒）

五、多态

多态就是面向对象编程最典型的一点了
下面我们还是用代码讲解吧
首先，我们先写一个测试类Demo4，同时该类也作为父类

package com.baidu.demo.test6;

public class Demo4 {

	//把该类做为父类 我们写一个方法 该方法用作被子类重写
	public void hero() {
		
	}
	
	
	public static void main(String[] args) {
		
		//实例化Demo4的子类Hero1()
		Demo4 d1 = new Hero1();
		//实例化Demo4的子类Hero2()
		Demo4 d2 = new Hero2();
		
		//这里我们虽然调用的都是hero方法，但是结果不一样哦
		d1.hero();
		d2.hero();

	}

}

创建两个Demo4的子类Hero1和Hero2

package com.baidu.demo.test6;

//继承自Demo4
public class Hero1 extends Demo4 {
	
	@Override
	//重写父类中的hero方法
	public void hero() {
		System.out.println("您创建了一个鲁班");
	}
	
	
	
}

package com.baidu.demo.test6;

//继承自Demo4
public class Hero2 extends Demo4 {
	
	@Override
	//重写父类中的hero方法
	public void hero() {
		System.out.println("您创建了一个百里玄策");
	}
	
}

运行结果：

六、内部类

所谓的内部类，其实就是在类里面的类
下面直接代码演示吧

package com.baidu.demo.test6;

//这已经是一个类了
public class Demo5 {
	
	//我们再在里面创建一个类
	class Demo6{
		//重写内部类的无参数构造器
		public Demo6() {
			System.out.println("这是内部类的构造器");
		} 
		
		//内部类和外部类一样，这里我在内部类写一个普通的方法
		public void printText() {
			System.out.println("随便啦");
		}
	}
	
	//声明一个静态内部类
	static class Demo7{
		public Demo7() {
			System.out.println("静态内部类被实例化");
		}
		
		public void pT() {
			System.out.println("静态的随便啦");
		}
	}
	
	public static void main(String[] args) {
		
		//实例化外部类
		Demo5 d5 = new Demo5();
		//内部类的实例化 实例化后将调用刚刚重写的无参构造器
		Demo6 d6 = d5.new Demo6();
		//调用内部类里面的方法和其它的调用方法是一样的
		d6.printText();
		
		//静态内部类的调用
		Demo7 d7 = new Demo5.Demo7();
		//其它大同小异
		d7.pT();
	}
}

运行结果：

七、instanceof运算符

所谓的instanceof运算符其实就是相当于==号
但是==号是用来判断左右两边的数字是否相等的
而instanceof可以通过返回一个布尔值来指出一个对象是否是这个特定类或者是它的子类的一个实例
代码演示：

package com.baidu.demo.test6;

public class Demo6 {

	public static void main(String[] args) {
		//这里我们实例化一个Integer类，这个类是Number类的子类
		Integer integer = new Integer(10);
		//我们可以通过instanceof运算符来得出实例化出来的integer是不是Number类的子类的实例 是的话打印出true
		System.out.println(integer instanceof Number);
	}

}

运行结果：

---

好啦，这节课就这么多啦
头都写晕。。。
有啥问题直接QQ497099936问我就好
24小时不定时在线回答各种问题
好啦
顾得白