Java面向对象思想精华（五）

一、抽象类

（一）抽象方法

1. 由 abstract 修饰的。
2. 只有方法的定义，没有具体的实现（具体方法体），也就是连 { } 花括号都没有直接以 ； 分号结束。

/**
 * 定一个抽象类，动物类的抽象属性与行为
 * @author Administrator
 *
 */
public abstract class Animal {
	//定义两个方法，描述动物吃的食物和叫声的区别
	abstract void eat();
	abstract void cry();
}

（二）抽象类

1. 由 abstract 修饰的。
2. 包含抽象方法的类必须是抽象类。
3. 不能被实例化。
4. 抽象类是需要被继承的。
   4.1. 要重写它的方法---------------变不完整为完整
   4.2. 抽象类中定义抽象类---------不常用。

• /**
   * 定一个抽象类，动物类的抽象属性与行为
   * @author Administrator
   *
   */
  public abstract class Animal {
  	//定义两个方法，描述动物吃的食物和叫声的区别
  	abstract void cry();
  	abstract String eat();
  }
  

• 	/**
  	 * 动物狗的食物与叫声
  	 */
  	public class Dog extends Animal {
  	@Override
  	public void cry() {
  		System.out.println("汪汪");
  	}
  	@Override
  	public String eat() {
  		return "狗吃骨头";
  	}
  }
  

• 	/**
  	 * 动物猫的食物与叫声
  	 */
  	public class Dog extends Animal {
  	@Override
  	public void cry() {
  		System.out.println("喵喵~");	
  	}
  	@Override
  	public String eat() {
  		return "猫吃鱼";
  	}
  }
  

• /**
  * 动物模拟器
  */
  public void play(Animal animal) {
  		System.out.print(animal.eat());
  		animal.cry();
  	}
  }
  

• /**
  * 动物模拟器
  */
  public class Mains {
  	public static void main(String[] args) {
  		Moni moni = new Moni();
  		moni.play(new Dog());
  		moni.play(new Cat());
  	}
  }
  

• 结果：
• 

（三）抽象类的意义

• 1.封存共有属性和行为方法，加 abstract 修饰符存到一个类中，属性私有化，行为公开化。-----------代码复用

• 2.为所有派生类（子类）提供统一的类型----------向上造型。

  public class Mains {
  public static void main(String[] args) {
  		Moni moni = new Moni();
  		Animal a = new Dog(2);//向上造型
  		moni.play(new Dog(7));
  		moni.play(new Cat(6));
  		a.cry();
  		a.getAge();
  	}
  }
  //结果显示：
  狗吃骨头汪汪~,今年7岁
  猫吃小鱼喵喵~，今年6岁
  汪汪~,今年2岁
  
  

• 3.可以包含抽象方法，为所有派生类提供统一的入口。派生类的行为不同，但入口是一致的

• 

• 上图动物属性（即年龄）私有化，给动物输出年龄。

二、内部类

（一）成员内部类

1. 应用率低，了解就行了。
2. 类中套类，外面的称为Outer外部类，里面的称为Inner内部类。
3. 内部类通常只服务于外部类，对外不具备可见性。
4. 内部类对象通常是在外部类中创建的。
5. 内部类中可以直接访问外部类的成员(包括私有的)
   内部类中有个隐式的引用指向了创建了它的外部类对象。
   eg: 外部类名.this.
6. 内部类的类体中不能声明静态方法和静态变量。

//成员内部类的演示
public class InnerClassDemo {
	public static void main(String[] args) {
		A  w1 = new A();
		//a  w2 = new a(); //内部类对外不具备可见性
	}
}


class A{	//外部类
	int i = 0;
	private String name;
	a w3 = new a();
	class a{	//内部类
		int j = 0;
		void showname() {
			System.out.println(name);
			System.out.println(A.this.name);
			System.out.println(this.j);		//this指的是a对象
		}
	}
}

（二）匿名内部类

• 1)若想创建一个类(派生类)的对象，并且对象只被创建一次，
  此时该类不必命名，称为匿名内部类。
• 2)匿名内部类中若想访问外部的变量，
  该变量必须是final的(JDK1.8之前的要求，1.8不做要求了)

//匿名内部类的演示
public class NstInnerClassDemo {
	public static void main(String[] args) {
		//1)创建了Aoo的一个派生类，但是没有名字
		//2)创建了该派生类的一个对象，名为o1
		//3)大括号中的为派生类的类体
		Aoo o1 = new Aoo() {
			
		};
		
		//1)创建了Aoo的一个派生类，但是没有名字
		//2)创建了该派生类的一个对象，名为o2
		//3)大括号中的为派生类的类体
		Aoo o2 = new Aoo() {
			
		};
		
		int num = 5;
		//1)创建了Boo的一个派生类，但是没有名字
		//2)创建了该派生类的一个对象，名为o3
		//3)大括号中的为派生类的类体
		Boo o3 = new Boo() {
			void show() {
				System.out.println("showshow");
				System.out.println(num); //JDK1.8之前，要求num必须是final的
			}
		};
		o3.show();
		
	}
}

abstract class Boo{
	abstract void show();
}

abstract class Aoo{
}

小提示：只要一个类是抽象类或者是一个接口，子类中的方法都可以使用匿名内部类来实现（例如：实现多线程要继承 Thread 类或者是继承 Runnable 接口）

后续的内容请耐心等等，马上就来！写作不易请点个赞3Q
若有错误之处，请各位点评下

所有章节目录在此处：https://blog.csdn.net/qq_41254299/article/details/106638651
转载请注明出处：https://blog.csdn.net/qq_41254299
本文出自【Superclover_的博客】