Java笔记（二）抽象类，接口，完全解耦，多重继承，内部类，静态类，匿名内部类

于 2020-05-27 19:13:28 发布
阅读量209 收藏
点赞数 1
分类专栏： Java基础及高级使用方法介绍 文章标签： java 接口 类 抽象类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41359358/article/details/106388064
版权

抽象类

包含抽象方法的类是抽象类，如果一个类包含一个或多个抽象方法，则这个类必须定义为抽象类。
如果从一个抽象类继承，并想创建该新类的对象，就必须为基类中的所有抽象方法提供方法定义。否则导出类也是抽象类，且编译器会强制用abstract限定这个类。
可以创建一个没有任何抽象方法的抽象类。
创建抽象类和抽象方法可以让类的抽象性明确起来，并告诉用户和编译器打算怎样使用它们。

package java_learn;

abstract class TOP{
	TOP(){
		print();
	}
	abstract void print();
}

public class ABSTRACT extends TOP{
	String m="hello";
	int a=2;
	ABSTRACT(){
		print();
		//print(a);
	}
	void print() {
		System.out.println(m);
	}
	void print(int s) {
		System.out.println(s);
	}
	public static void main(String []args) {
		ABSTRACT A=new ABSTRACT();
		//A.print(m);错误，静态方法不能使用非静态变量
	}
}

输出：

null
hello

抽象类可以声明并定义构造函数。因为你不可以创建抽象类的实例，所以构造函数只能通过构造函数链调用（Java中构造函数链指的是从其他构造函数调用一个构造函数），例如，当你创建具体的实现类。现在一些面试官问，如果你不能对抽象类实例化那么构造函数的作用是什么？好吧，他可以用来初始化抽象类内部声明的通用变量，并被各种实现使用。另外，即使你没有提供任何构造函数，编译器将为抽象类添加默认的无参数的构造函数，没有的话你的子类将无法编译，因为在任何构造函数中的第一条语句隐式调用super（），Java中默认超类的构造函数。
https://blog.csdn.net/JW614718/article/details/88410215

package java_learn;

abstract class TOP{
}

public class ABSTRACT extends TOP{
	String m="hello";
	int a=2;
	ABSTRACT(){
	}
	void print() {
		System.out.println(m);
	}
	static void print(TOP e) {
		((ABSTRACT)e).print();
	}
	public static void main(String []args) {
		TOP M=new ABSTRACT();
		ABSTRACT.print(M);
	}
}


package java_learn;

abstract class TOP{
	void print() {};
}

public class ABSTRACT extends TOP{
	String m="hello";
	int a=2;
	ABSTRACT(){
	}
	void print() {
		System.out.println(m);
	}
	static void print(TOP e) {
		e.print();
	}
	public static void main(String []args) {
		TOP M=new ABSTRACT();
		ABSTRACT.print(M);
	}
}

接口

interface产生了一个完全抽象的类，根本没有提供任何的具体实现。允许创建者确定方法名，参数列表和返回类型，但是没有任何的方法体。接口只提供形式，未提供任何具体实现。
接口中的方法无论是否显示声明未为public，他也是public的。因为当 要实现一个接口时，在接口中被定义的方法必须为public，否则他只能得到包访问权限，这样在方法被继承时，其可访问权限就降低了。

public class ABSTRACT implements INTER{
	ABSTRACT(){
	}
	public void out() {
		//必须声明为public，不能降低可访问性
	}
	}
	
public interface INTER {
	int num=10;
	void out();
}

策略设计模式，即创建一个能够根据所传递的参数对象的不同而具有不同行为的方法

完全解耦

https://www.jianshu.com/p/965ae81ef7de

适配器：
在这里插入图片描述

多重继承

在这里插入图片描述可继承任意数量接口，并可以向上转型为每个接口。

多重继承

在这里插入图片描述在这里插入图片描述

内部类

将一个类的定义放到另一个类的内部，这就是内部类。
在这里插入图片描述
链接到外部类
生成一个内部类对象时，此对象与制造他的外围对象之间有了一种联系，他能访问其外围对象的所有成员，而不需要任何特殊条件，还能访问外围类的所有元素。
在这里插入图片描述需要生成对外部类对象的引用，可以使用外部类的名称后面紧跟圆点和this。

public class innerclass {
	private int aa;
	int bb;
	char cc;
	class inner{
		String s;
		public inner(String s) {
			aa=1;//可访问
			this.s=s;
		}
		public innerclass ret() {
			return innerclass.this;
		}
	}
	public inner out() {
		return new inner("hello");
	}
	public void output() {
		System.out.println("innerclass.output");
	}
	public static void main(String args[]) {
		innerclass a=new innerclass();
		innerclass.inner b=a.out();
		b.ret().output();
	}
}

输出：innerclass.output

创建内部类的对象，必须在new表达式中提供对其他外部类对象的引用，使用到.new语法。
在这里插入图片描述
想直接创建内部类对象，必须使用外部类对象来创建内部类对象。在拥有外部类对象之前都不能 创建内部类对象。
如果创建的是嵌套类（静态内部类），就不需要对外部类的引用了。

package java_learn;


public class innerclass {
	private int aa;
	int bb;
	char cc;
	static class inner{
		String s;
		public inner(String s) {
			this.s=s;
		}
		public innerclass ret() {
			return new innerclass();
		}
	}
	public inner out() {
		return new inner("hello");
	}
	public void output() {
		System.out.println("innerclass.output");
	}
	public static void main(String args[]) {
		inner b=new inner("s");
		b.ret().output();
	}
}

在另一个独立的类中，创建内部类的实例。

package java_learn;


public class innerclass {
	private int aa;
	int bb;
	char cc;
	class inner{
		String s;
		public inner(String s) {
			this.s=s;
		}
		public innerclass ret() {
			return new innerclass();
		}
	}
	public inner out() {
		return new inner("hello");
	}
	public void output() {
		System.out.println("innerclass.output");
	}
	public static void main(String args[]) {}
}

class outer1{
	void outer1() {
		innerclass a=new innerclass();
		innerclass.inner b=a.new inner("s");
		innerclass.inner c=a.out();
	}
}


package java_learn;

public interface INTER {
	int a=1;//必须初始化
	String name();
	//Object process(Object input);
}

package java_learn;


public class innerclass {
	private class inner implements INTER{
		String s;
		public inner(String s) {
			this.s=s;
		}
		public innerclass ret() {
			return new innerclass();
		}
		public String name() {
			return "ssd";
		}
	}
	public inner out() {
		return new inner("hello");
	}
	public void output() {
		System.out.println("innerclass.output");
	}
	public static void main(String args[]) {}
}

class outer1{
	void outer1() {
		innerclass a=new innerclass();
		INTER m=a.out();//向上转型
		String string=m.name();
		System.out.println(string);
		
		innerclass.inner b=a.new inner("s");//错误！！！！
	}
}

innerclass.inner b=a.new inner(“s”);//错误！！！！
The type innerclass.inner is not visible

内部类向上转型为其基类，尤其转型为接口时，内部类就有了用武之地。
上例private内部类对外是不可见的，通过这种方式可以完全阻止任何依赖于类型的编码，完全隐藏实现的细节。内部类不能访问任何新增加的，原本不属于接口的方法，所以扩展接口没有价值。

package java_learn;


public class innerclass {
	int aa;
	int bb;
	char cc;
	class inner{
		String s;
		private int t;
		public inner(String s) {
			this.s=s;
		}
		public innerclass ret() {
			return new innerclass();
		}
		public innerclass ret1() {
			return innerclass.this;
		}
		public String name() {
			return "ssd";
		}
		public void change() {
			aa=4;
		}
	}
	public inner out() {
		return new inner("hello");
	}
	public void output() {
		System.out.println("innerclass.output");
	}
	public static void main(String args[]) {
		outer1 a=new outer1();
		a.outer1();

	}
}

class outer1{
	void outer1() {
		innerclass a=new innerclass();
		System.out.println(a.aa);
		innerclass.inner b=a.new inner("s");
		b.change();
		System.out.println(a.aa);
		innerclass c=b.ret();
		System.out.println(c.aa);
		innerclass d=b.ret1();
		System.out.println(d.aa);
	}
}

输出：0
4
0
4

外部类可以访问内部类private元素

方法和作用域内的内部类

可以在一个方法或任意的作用域内定义内部类
在这里插入图片描述方法作用域创建一个完整的类。局部内部类
在这里插入图片描述在这里插入图片描述

静态类

静态类不用先创建外部类。可以静态类看做外部类的静态变量，使用就不要外部类实例；而非静态就必须先实例化。

https://www.cnblogs.com/xf-686/archive/2019/06/27/11098274.html

匿名内部类

匿名内部类是局部内部类的更深入一步。**假如只创建某类的一个对象时，就不必将该类进行命名。**匿名内部类的前提是存在一个类或者接口，且匿名内部类是写在方法中的。只针对重写一个方法时使用，需要重写多个方法时不建议使用

package java_learn;


public class innerclass {
	protected void test() {
		System.out.println("inner.test");
	}
}

package package2;

import java_learn.innerclass;

public class protecttest {
	public void get() {
		new innerclass() {
			public void test() {
				super.test();
			}
		}.test();;
	}
public static void main(String args[]) {
	//innerclass b=new innerclass();
	protecttest a=new protecttest();
	a.get();
}
}

用匿名内部类访问了不同包的protected方法。

class A{
	int a;
	public A(int a) {
		this.a=a;
	}
	public void out() {
		System.out.println(a);
	}
}
public class protecttest {
public A ret1() {
	return new A(1);
}
public A ret2() {
	return new A(2) {
		public void out() {
			System.out.println("anonymous class");
		}
	};
}
public static void main(String args[]) {
	protecttest a=new protecttest();
	A a1=a.ret1();
	A a2=a.ret2();
	a1.out();
	a2.out();
}
}

在这里插入图片描述在这里插入图片描述在这里插入图片描述

嵌套类

如果不需要内部类对象与外围类对象之间有联系，将内部类声明为static，这通常叫嵌套类。
在这里插入图片描述

接口内的类

嵌套类可以作为接口的一部分，放到接口中的类自动是final static的。

在这里插入图片描述

内部类好处

在这里插入图片描述在这里插入图片描述在这里插入图片描述

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

密码猿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值