JAVA高级类特性(三)

最新推荐文章于 2025-07-23 17:50:48 发布

原创最新推荐文章于 2025-07-23 17:50:48 发布 · 404 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

JAVASE 专栏收录该内容

31 篇文章

订阅专栏

一、接口

1）有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是Java不支持多重继承。有了接口，就可以得到多重继承的效果。

2）接口是抽象方法和常量值的定义的集合

3）从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。

4）实现接口类

class A implements InterfaceA{}

5）一个类可以实现多个接口，接口也可以继承其他接口。

6）声明接口时，如果在关键字interface前面加上public关键字，就称这样的接口称为public接口。public接口可以被任何一个类声明实现。如果一个接口不加public修饰，就称之为友好类接口，友好接口可以被与该接口在同一包中的类声明实现。

package com.atguigu.java1;
/*
 * 接口（interface）  是与类并行的一个概念
 * 1.接口可以看做是一个特殊的抽象类。是常量与抽象方法的一个集合，不能包含变量、一般的方法。
 * 2.接口是没有构造器的。
 * 3.接口定义的就是一种功能。此功能可以被类所实现（implements）。
 * 比如：class CC extends DD implements AA
 * 4.实现接口的类，必须要重写其中的所有的抽象方法，方可实例化。若没有重写所有的抽象方法，则此类仍为一个抽象类
 * 5.类可以实现多个接口。----java 中的类的继承是单继承的
 * 6.接口与接口之间也是继承的关系，而且可以实现多继承
 * >5,6描述的是java中的继承的特点。
 * 
 */
public class TestInterface {
	public static void main(String[] args) {
		System.out.println(AA.I);
//		AA.I = 13;
	}
}

interface AA{
	//常量:所有的常量都用public static final修饰
	int I = 12;
	boolean FLAG = false;
//	int i;
	//抽象方法:所有的都用public abstract修饰
	void method1();
	void method2();
}

abstract class BB implements AA{
	
}
class DD{
	
}
interface MM{
	void method3();
}
class CC extends DD implements AA,MM{//在实现接口的时候要将public显式的写出来
	public void method1(){
		
	}
	public void method2(){
		
	}
	public void method3(){
		
	}
}
//接口之间仍为继承关系！(多继承)
interface JJ extends MM,AA{
	void method4();
}

class GG implements JJ{

	@Override
	public void method3() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void method4() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void method1() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void method2() {
		// TODO Auto-generated method stub
		
	}
	
}

对于接口的总结：

1）通过接口可以实现不相关类的相同行为，而不需要考虑这些类之间的层次关系。

2）通过接口可以指明多个类需要实现的方法，一般用于定义对象的扩张功能。

3）接口主要用于定义规范，解除耦合关系

二、接口的多态性

在接口的多态中，指向接口的引用必须是指定这实现了该接口的一个类的实例程序，在运行时，根据对象引用的实际类型来执行对应的方法。

继承都是单继承，只能为一组相关的类提供一致的服务接口。但是接口可以是多继承多实现，它能够利用一组相关或者不相关的接口进行组合与扩充，能够对外提供一致的服务接口。所以它相对于继承来说有更好的灵活性。

package com.atguigu.java;
//接口与具体的实现类之间也存在多态性
public class TestInterface {
	
	public static void main(String[] args) {
		Duck d = new Duck();
		TestInterface.test1(d);
		TestInterface.test2(d);
		TestInterface.test3(d);
	}
	
	public static void test1(Runner r){//Runner r = new Duck();
		r.run();//虚拟方法调用
	}
	public static void test2(Swimmer s){//Swimmer s = new Duck();
		s.swim();
	}
	public static void test3(Flier f){//Flier f = new Duck();
		f.fly();
	}
}

interface Runner{
	public abstract void run();
}
interface Swimmer{
	void swim();
}
interface Flier{
	void fly();
}

class Duck implements Runner,Swimmer,Flier{

	@Override
	public void fly() {
		System.out.println("丑小鸭也可以变成白天鹅！");
	}

	@Override
	public void swim() {
		System.out.println("红掌拨清波");
	}

	@Override
	public void run() {
		System.out.println("鸭子屁股扭扭的走路");
	}
	
}

接口的工厂设计模式

package com.atguigu.java;
//接口的应用：工厂方法的设计模式
public class TestFactoryMethod {
	public static void main(String[] args) {
		IWorkFactory i = new StudentWorkFactory();
		i.getWork().doWork();
		
		IWorkFactory i1 = new TeacherWorkFactory();
		i1.getWork().doWork();
	}
}

interface IWorkFactory{
	Work getWork();
}
class StudentWorkFactory implements IWorkFactory{

	@Override
	public Work getWork() {
		return new StudentWork();
	}
	
}
class TeacherWorkFactory implements IWorkFactory{

	@Override
	public Work getWork() {
		return new TeacherWork();
	}
	
}

interface Work{
	void doWork();
}

class StudentWork implements Work{

	@Override
	public void doWork() {
		System.out.println("学生写作业");
	}
	
}
class TeacherWork implements Work{

	@Override
	public void doWork() {
		System.out.println("老师批改作业");
	}
	
}

代理模式

package com.atguigu.java;
//接口的应用：代理模式
public class TestProxy {
	public static void main(String[] args) {
		Object obj = new ProxyObject();
		obj.action();
	}
}

interface Object{
	void action();
}
//代理类
class ProxyObject implements Object{
	Object obj;
	
	public ProxyObject(){
		System.out.println("代理类创建成功");
		obj = new ObjctImpl();
	}
	
	public void action(){
		System.out.println("代理类开始执行");
		obj.action();
		System.out.println("代理类执行结束");
	}
}
//被代理类
class ObjctImpl implements Object{

	@Override
	public void action() {
		System.out.println("=====被代理类开始执行======");
		System.out.println("=====具体的操作======");
		System.out.println("=====被代理类执行完毕======");
		
	}
	
}

三、abstract类与接口的比较

1）abstract类和接口都可以由abstract方法。

2）接口中只可以有常量，不能有变量，而abstract类中既可以有常量也可以有变量。

3）abstract类中可以有非abstract方法，接口不可以。

四、内部类

成员内部类：

package com.atguigu.java;
/*
 * 类的第5个成员：内部类
 * 1.相当于说，我们可以在类的内部再定义类。外面的类：外部类。里面定义的类：内部类
 * 2.内部类的分类：成员内部类（声明在类内部且方法外的）  vs 局部内部类(声明在类的方法里)
 * 3.成员内部类：
 * 		3.1是外部类的一个成员：①可以有修饰符（4个）②static final ③可以调用外部类的属性、方法
 * 			
 * 		3.2具体类的特点：①abstract ②还可以在其内部定义属性、方法、构造器
 * 
 * 4.局部内部类：
 * 
 * 5.关于内部类，大家掌握三点：
 *   ①如何创建成员内部类的对象（如：创建Bird类和Dog类的对象）
 *   ②如何区分调用外部类、内部类的变量(尤其是变量重名时)
 *   ③局部内部类的使用 （见TestInnerClass1.java）
 * 
 */
public class TestInnerClass {
	public static void main(String[] args) {
		//创建静态内部类的对象：可以直接通过外部类调用静态内部类的构造器
		Person.Dog d = new Person.Dog();//Person.new Dog();
		//Person.Bird b = new Person.Bird();
		//创建非静态的内部类的对象：必须先创建外部类的对象，通过外部类的对象调用内部类的构造器
		Person p = new Person();
		Person.Bird b = p.new Bird();//new p.Bird();
		b.info();
		b.setName("杜鹃");
	}
}

class Person{
	String name = "韩梅梅";
	int age;
	//成员内部类(非static的)
	class Bird{
		String name = "黄鹂";
		int id;
		
		public Bird(){
			
		}
		public void setName(String name){
			System.out.println(name);//杜鹃
			System.out.println(this.name);//黄鹂
			System.out.println(Person.this.name);//韩梅梅
		}
		public void info(){
			show();
		}
	}
	//成员内部类(静态内部类)
	static class Dog{
		
	}
	
	public void show(){
		System.out.println("我是show()方法");
	}
	
	public void method1(){
		class A{
			
		}
	}
}

局部内部类：

package com.atguigu.java;
/*
 * 关于局部内部类的使用
 */
public class TestInnerClass1 {
	
}

class OuterClass{
	//局部内部类
	//如下的使用方式较少
	public void method1(){
		
		class InnnerClass{
			
		}
	}
	//常常使用一个方法，使其返回值为某个类或接口的对象。而这个类或接口在方法内部创建
	//使用方式一
	public Comparable getComparable(){
		//1.创建一个实现Comparable接口的类:局部内部类
		class MyComparable implements Comparable{

			@Override
			public int compareTo(java.lang.Object o) {
				return 0;
			}
			
		}
		//2.返回一个实现类的对象
		return new MyComparable();
	}
	//使用方式二
	public Comparable getComparable1(){
		//返回一个实现Comparable接口的匿名内部类的对象
		return new Comparable(){

			@Override
			public int compareTo(java.lang.Object o) {
				// TODO Auto-generated method stub
				return 0;
			}
			
		};
	}
}

匿名内部类的应用举例：

package com.atguigu.java;

public class TestProduct {
	public static void main(String[] args) {
		TestProduct t = new TestProduct();
		//方式一：创建一个实现Product接口的类的对象，并将此对象传入方法中
		NoteBook n = new NoteBook();
		t.show(n);
		//方式二：创建一个实现Product接口的匿名类的对象
		Product p = new Product(){
			public void getName(){
				System.out.println("Galaxy Note3");
			}
			public void getPrice(){
				System.out.println("￥5288");
			}
		};
		//方式三：创建一个实现Product接口的匿名类的匿名对象
		t.show(new Product(){
			public void getName(){
				System.out.println("Iphone5s");
			}
			public void getPrice(){
				System.out.println("￥5288");
			}
		});
		System.out.println();
		Product p1 = t.getProduct();
		p1.getName();
		p1.getPrice();
		
	}
	
	//局部内部类的使用
	public Product getProduct(){
//		//方式一：实现Product接口的局部内部类
//		class Camera implements Product{
//
//			@Override
//			public void getName() {
//				System.out.println("数码相机");
//			}
//
//			@Override
//			public void getPrice() {
//				System.out.println("4000");
//			}
//			
//		}
//		return new Camera();
		//方式二：实现Product接口的匿名局部内部类
		return new Product(){
			@Override
			public void getName() {
				System.out.println("电纸书");
			}

			@Override
			public void getPrice() {
				System.out.println("1000");
			}
		};
		
	}
	
	public void show(Product p){
		p.getName();
		p.getPrice();
	}
}

interface Product{
	void getName();
	
	void getPrice();
}

class NoteBook implements Product{
	public void getName(){
		System.out.println("HP笔记本");
	}
	public void getPrice(){
		System.out.println("￥5000");
	}
}

———————————————————————————————————————————————4

面向对象的总结：