面向对象基础四

最新推荐文章于 2024-08-14 10:53:54 发布

lz_matlab

最新推荐文章于 2024-08-14 10:53:54 发布

阅读量122

点赞数

分类专栏： Java 文章标签： jvm java windows

本文链接：https://blog.csdn.net/asdsdwuwang/article/details/128373233

版权

Java 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

面向对象基础四

#抽象类

在实际设计中，有这样的需要，就是某个基类不允许创建对象。我们可以在定义该类时，在前面加上 abstract 关键字，该类不能被实例化，如果要创建抽象类的对象，编译器会报错。

抽象类也有构造方法，因为其子类会调用父类的构造方法，该构造方法在子类创建对象时被调用。

#抽象方法

在定义方法时，如果在前面加上abstract关键字，这时该方法没有方法体，这种方法称为抽象方法。例如：

public abstract void m1();

抽象方法只能出现在抽象类中，子类继承父类时，如果子类被定义为非抽象类，则在子类中必须实现父类继承来的抽象方法，除非它也被定义为抽象类。

抽象类体中，可以包含抽象方法，也可以不包含抽象方法。但类体中包含抽象方法的类必须要声明为抽象类。

不管是抽象类还是抽象方法都不能被final修饰，这是因为final类不能被继承，final方法不能被复写，而抽象类需要被继承，抽象方法需要被复写，很显然这两者是冲突的。

#接口（interface）

接口也是一类引用类型，interface 比抽象类更进一步，在interface中所有的方法均不能有方法体。interface 非常有用，因为在Java中类不允许多重继承，但是某个类可以实现多个interface，接口和接口之间可以多继承。

#接口的特点

在抽象的类中，并非所有的方法都是抽象的，那些抽象的方法在子类中实现。而在interface中所有的方法都是抽象的，不能有方法体。
接口中没有构造方法,无法被实例化。
接口中的成员变量和方法的存取控制权限必须是public，所以存取控制符修饰符可以省略，就是指public。
接口中也可以有成员变量，但是这些成员变量必须是 static 和 final，在接口中要给域初始化，这两个关键字可以省略。
接口中只能出现：常量、方法

#接口的定义与实现

以interface取代class关键字就是定义接口的形式。如果interface需要公开，则interface 前也可以有public，因此也要求文件名也必须和接口名一致。

一个类可以实现多个接口，使用关键字 implements 后跟若干接口名，接口名之间用逗号分隔。实现接口的类除非定义为抽象类，否则，一个非抽象的类在实现接口时，需要将接口中所有的方法进行实现。

因为接口中的方法如果没有存取控制符修饰的话，就是public，所以在实现接口的类中，应在方法前加上存取控制符 public。

如下例：

interface A{
  	int i=0;
  	void m();
}

class B implements A{
  	//int i=9;
  	public void m(){}
  	
	public static void main(String s[]){
    	B x=new B();
    	System.out.println(x.i);
  	}
}

再如：

interface CanFight {
	void fight();
}

interface CanSwim {
	void swim();
}

interface CanFly {
	void fly();
}

class ActionCharacter {
	public void fight() {}
}

class Hero extends ActionCharacter implements CanFight, CanSwim, CanFly {
	public void swim() {}
	public void fly() {}
}

public class Adventure {
	public static void t(CanFight x) { x.fight(); }
	public static void u(CanSwim x) { x.swim(); }
	public static void v(CanFly x) { x.fly(); }
	public static void w(ActionCharacter x) { x.fight(); }

	public static void main(String[] args) {
		Hero h = new Hero();
		t(h); // Treat it as a CanFight
		u(h); // Treat it as a CanSwim
		v(h); // Treat it as a CanFly
		w(h); // Treat it as an ActionCharacter
	}
}

注意在接口CanFight 和类ActionCharacter 中fight( )一样，所以在Hero中没有提供定义。

#接口和抽象类的区别

相同点
- 都包含抽象方法
- 都不能被实例化
- 都是引用数据类型。可以声明抽象类及接口变量，并将子类的对象赋给抽象类变量，或将实现接口的类的变量赋给接口变量
不同点
- 只能继承一个抽象类，但可以实现多个接口，接口可以多继承
- 抽象类的访问权限控制同普通类，接口的访问权限只有public即是默认权限，所以public可以省略
- 接口中只能声明常量，不能声明变量
- 接口中只能声明抽象方法
使用接口的好处
- 可以使项目分层，所有层都面向接口开发，开发效率提高了。
- 接口使代码和代码之间的耦合度降低，就像内存条和主板的关系，变得“可插拔”。可以随意切换。
- 接口和抽象类都能完成某个功能，优先选择接口。

例子：

public interface CustomerService{
	
	//定义一个退出系统的方法
	void logout();
	
}

public class CustomerServiceImpl implements CustomerService{

	//对接口中的抽象方法进行实现。
	public void logout(){
		
		System.out.println("成功退出系统！");
		
	}
	
}

public class Test{

	//入口
	public static void main(String[] args){
		
		//要执行CustomerServiceImpl中的logout方法.
		
		//以下程序面向接口去调用	
		CustomerService cs = new CustomerServiceImpl(); //多态
		
		//调用
		cs.logout();
	}
}

#内部类

内部类就是在一个类中所定义的类，它可以在一个类中定义，也可以在一个方法中定义，如下：

class EnclosingClass {
 	... 
  	static class StaticNestedClass { ... }
  	class InnerClass { ... } 
}

内部类像类的其他成员一样，有自己的作用域，且内部类的名称不能与所嵌套的类重名。
内部类可以是由static修饰。
内部类也可以由abstract修饰，该内部类不能被实例化。
因为内部类在一个类的内部被定义，则修饰它的的访问控制修饰符可以是private、protected、public、缺省等权限。
非静态内部类的成员不能声明为static类型
使用内部类也相当于变相的实现了多重继承

//: Parcel2.java
// Returning a reference to an inner class.
public class Parcel{
  	class Contents {
    	private int i = 11;
    	public int value() { return i; }
  	}

  	class Destination {
    	private String label;

    	Destination(String whereTo) {
      		label = whereTo;
    	}

    	String readLabel() { return label; }
  	}

  	public Destination to(String s) {
    	return new Destination(s);
  	}

  	public Contents cont() {
    	return new Contents();
  	}

  	public void ship(String dest) {
    	Contents c = cont();
    	Destination d = to(dest);
    	System.out.println(d.readLabel());
  	}

  	public static void main(String[] args) {
    	Parcel p = new Parcel2();
    	p.ship("Tanzania");
    	Parcel q = new Parcel2();
    
		// Defining references to inner classes:
    	Parcel.Contents c = q.cont();
		// Parcel2.Contents c = p.new Contents();
		//如果Contents为static的话，可以new Parcel2.Contents();
    	Parcel.Destination d = q.to("Borneo");
  	}
}

#非静态内部类

非静态内部类可以等同看做实例变量非静态内部类中不能有静态声明. 非静态内部类可以访问外部类所有的数据.

#静态内部类

静态内部类可以等同看做静态变量静态内部类可以直接访问外部类的静态数据,无法直接访问非静态成员。内部类重要的作用：可以访问外部类中私有的数据。

#局部内部类

局部内部类等同于局部变量，它定义在方法内部，可出现在形式参数定义处或者方法体处，不能使用访问控制符，不能使用static。局部内部类可以访问方法中的局部变量，但该局部变量必须是使用final修饰的。这是为什么呢？这是因为：

JAVA语言的编译程序的设计者当然希望能无条件访问局部变量，从理论上这是很自然的要求，但是，编译技术是无法实现的或实现代价极高。

困难在何处?到底难在哪儿?局部变量的生命周期与局部内部类的对象的生命周期的不一致性!
设方法f()被调用,从而在它的调用栈中生成了变量i，此时产生了一个局部内部类对象inner_object，它访问了该局部变量i。当方法f()运行结束后,局部变量i就已死亡了，不存在了。但局部内部类对象inner_object还可能一直存在(在没有人再引用该对象时,它才会死亡)，它不会随着方法f()运行结束死亡。这时:出现了一个"荒唐"结果:局部内部类对象inner_object要访问一个已不存在的局部变量i!
如何才能实现?当变量是final时,通过将final局部变量复制一份，复制品直接作为局部内部中的数据成员。这样，当局部内部类访问局部变量时，其实真正访问的是这个局部变量的"复制品"(即:这个复制品就代表了那个局部变量)。因此，当运行栈中的真正的局部变量死亡时，局部内部类对象仍可以访问局部变量(其实访问的是复制品)，给人的感觉:好像是局部变量的生命期延长了。
那么，核心的问题是，怎么才能使得访问复制品与访问真正的原始的局部变量，其语义效果是一样的呢? 当变量是final时，若是基本数据类型，由于其值不变，因而，其复制品与原始的量是一样。语义效果相同。(若:不是final，就无法保证复制品与原始变量保持一致了。因为，在方法中改的是原始变量，而局部内部类中改的是复制品)
当变量是final时，若是引用类型，由于其引用值不变(即:永远指向同一个对象)。因而，其复制品与原始的引用变量一样，永远指向同一个对象(由于是final，从而保证:只能指向这个对象，再不能指向其它对象)。达到:局部内部类中访问的复制品与方法代码中访问的原始对象，永远都是同一个，即:语义效果是一样的。否则:当方法中改变原始变量，而局部内部类中改复制品时，就无法保证:复制品与原始变量保持一致了(因此:它们原本就应该是同一个变量。)

public class OuterClass{
	//方法
	public void m1(){
		//局部变量
		final int i = 10;
		//局部内部类
		//局部内部类不能用访问控制权限修饰符修饰。
		class InnerClass{
			//内部类不能有静态声明
			//public static void m1(){}
			//成员方法
			public void m2(){
				System.out.println(i); // 10
			}
		}
		//调用m2
		InnerClass inner = new InnerClass();
		inner.m2();
	}
	//入口
	public static void main(String[] args){
		OuterClass oc = new OuterClass();
		oc.m1();
	}
}

#匿名内部类

匿名内部类：指的是类没有名字。由于匿名内部类没有类名，因此匿名内部类不能显式声明构造方法。匿名内部类在定义时即被实例化，所以匿名内部类不能定义为抽象类。

/*
	匿名内部类：指的是类没有名字.
*/
public class Test{
	
	//静态方法
	public static void t(CustomerService cs){
		cs.logout();
	}
	//入口
	public static void main(String[] args){
		//使用匿名内部类的方式执行t方法
		//整个这个"new CustomerService(){}"就是个匿名内部类
		t(new CustomerService(){
			public void logout(){
				System.out.println("exit!");
			}
		});
		//匿名内部类的优点：少定义一个类.
		//缺点：无法重复使用!
	}
}
//接口
interface CustomerService{
	//退出系统
	void logout();
}

lz_matlab

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
面向对象基础四

以interface取代class关键字就是定义接口的形式。如果interface需要公开，则interface前也可以有public，因此也要求文件名也必须和接口名一致。一个类可以实现多个接口，使用关键字implements后跟若干接口名，接口名之间用逗号分隔。实现接口的类除非定义为抽象类，否则，一个非抽象的类在实现接口时，需要将接口中所有的方法进行实现。因为接口中的方法如果没有存取控制符修饰的话，就是public，所以在实现接口的类中，应在方法前加上存取控制符public。void m();
复制链接

扫一扫

专栏目录