【黑马程序员】抽象类、接口和内部类

:抽象类
 (1)把多个共性的东西提取到一个类中，这是继承的做法。
    但是呢，这多个共性的东西，在有些时候，方法声明一样，但是方法体。
    也就是说，方法声明一样，但是每个具体的对象在具体实现的时候内容不一样。
    所以，我们在定义这些共性的方法的时候，就不能给出具体的方法体。
    而一个没有具体的方法体的方法是抽象的方法。
    在一个类中如果有抽象方法，该类必须定义为抽象类。
 (2)抽象类的特点
  A:抽象类和抽象方法必须用关键字abstract修饰
  B:抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类
  C:抽象类不能实例化
  D:抽象类的子类
   a:是一个抽象类。
   b:是一个具体类。这个类必须重写抽象类中的所有抽象方法。
 (3)抽象类的成员特点：
  A:成员变量
   有变量，有常量
  B:构造方法
   有构造方法
  C:成员方法
   有抽象，有非抽象
 (4)抽象类的练习
  A:猫狗案例练习
  B:老师案例练习
  C:学生案例练习
  D:员工案例练习
 (5)抽象类的几个小问题
  A:抽象类有构造方法，不能实例化，那么构造方法有什么用?
   用于子类访问父类数据的初始化
  B:一个类如果没有抽象方法,却定义为了抽象类，有什么用?
   为了不让创建对象
  C:abstract不能和哪些关键字共存
   a:final 冲突
   b:private 冲突
   c:static 无意义

4

/*
	定义抽象类 
	格式 :
		abstract class 类名{} 

	举例 :

	抽象类中的 方法

		抽象方法  abstract void eat();
		没有方法体,没有{},以; 结尾.  


		非抽象方法 
			void sleep(){
				syso ....
			}

	抽象类子类:
		1.非抽象类,但是必须重写父类的抽象方法

		2.抽象类,无须管抽象方法,但是子类不能new了

	抽象类中,有构造方法,但是有不能new,那么构造方法干嘛的呢? 
	给子类用的!!!

	抽象类,一样可以使用多态来创建子类对象 .


	总结: 一般来说,会把父类定义为抽象的类.测试的时候,可以通过多态,来实现子类功能. 



							抽象类						接口

	成员变量			变量,常量			

	构造方法			有

	成员方法			抽象,非抽象
	


*/

class AnimalTest{

	public static void main(String[] args){

		

		//Cat c  = new Cat();  // 抽象的,无法创建对象
		//c.eat();


		//Animal a = new Animal();

		//多态
		Animal a  = new Cat();

		a.eat();
		System.out.println(a.num);
		System.out.println(a.num2);

		

	}
}

abstract class Animal{
	
	int num =10;
	final int num2 = 20;
	Animal(){} 
	//eat 
	public abstract void eat();
	


	//sleep
	public void sleep(){
		System.out.println("合眼就睡");
	}


}

 class Cat extends Animal{
	

	Cat(){
		super();
	}
	//eat

	public  void eat(){
		System.out.println("用爪子抓鱼,用舌头添鱼肉,不吐刺儿..喵喵儿~~");
	}

	//public abstract void eat();

		//sleep
	public void sleep(){
		System.out.println("合眼就睡,白天,想睡就睡");
	}


}

/*
	接口:引用数据类型 interface  
	

	interface 接口名{}


	本质:它是一种规则.
	定义接口,就是定义了规则.

	实现接口,相当于扩展了功能. 


	实现接口: implements
		举例:  Cat implements Train 

	注意: 
	1. 接口中的方法,是抽象的.
	2. 接口的子类,必须重写接口的中的所有的抽象方法 

*/

class MiaoXingRenTest{

	public static void main(String[] args){

		System.out.println();

		MiaoXingRen  mxr = new MiaoXingRen();
		mxr.eat();
		mxr.count();

	}
}


interface Train{
//	public void count(){
//		System.out.println("数数");
//	}

	public abstract void count();

	public abstract void sing(); 
}

class Animal  {
	public void eat(){
		System.out.println("吃东西");
	}

}

class Cat extends Animal{

	public void eat(){
		System.out.println("吃鱼");
	}
}
/*
	喵星人,会数数   
*/
class MiaoXingRen extends Cat implements Train {
	
	public void count(){
		System.out.println("数数");
	}

	
	public void sing(){
		System.out.println("按我的唱法来");
	}
}

/*
	抽象类的成员特点：
		成员变量：既可以是变量，也可以是常量。
		构造方法：有。
					用于子类访问父类数据的初始化。
		成员方法：既可以是抽象的，也可以是非抽象的。
		
	抽象类的成员方法特性：
		A:抽象方法 强制要求子类做的事情。
		B:非抽象方法 子类继承的事情，提高代码复用性。
*/
abstract class Animal {
	public int num = 10;
	public final int num2 = 20;

	public Animal() {}
	
	public Animal(String name,int age){}
	
	public abstract void show();
	
	public void method() {
		System.out.println("method");
	}
}

class Dog extends Animal {
	public void show() {
		System.out.println("show Dog");
	}
}

class AbstractDemo2 {
	public static void main(String[] args) {
		//创建对象
		Animal a = new Dog();
		a.num = 100;
		System.out.println(a.num);
		//a.num2 = 200;
		System.out.println(a.num2);
		System.out.println("--------------");
		a.show();
		a.method();
	}
}

内部类(理解)
	(1)把类定义在另一个类的内部，该类就被称为内部类。
		举例：把类B定义在类A中，类B就被称为内部类。
	(2)内部类的访问规则
		A:可以直接访问外部类的成员，包括私有
		B:外部类要想访问内部类成员，必须创建对象
	(3)内部类的分类
		A:成员内部类
		B:局部内部类
	(4)成员内部类
		A:private 为了数据的安全性
		B:static 为了访问的方便性
		
		成员内部类不是静态的：
			外部类名.内部类名 对象名 = new 外部类名.new 内部类名();
		成员内部类是静态的：
			外部类名.内部类名 对象名 = new 外部类名.内部类名();
	(5)成员内部类的面试题(填空)
		30,20,10
		
		class Outer {
			public int num = 10;
			
			class Inner {
				public int num = 20;
				
				public viod show() {
					int num  = 30;
					
					System.out.println(num);
					System.out.println(this.num);
					System.out.println(Outer.this.num);
				}
			}
		}
	(6)局部内部类
		A:局部内部类访问局部变量必须加final修饰。
		B:为什么呢?
			因为局部变量使用完毕就消失，而堆内存的数据并不会立即消失。
			所以，堆内存还是用该变量，而改变量已经没有了。
			为了让该值还存在，就加final修饰。
			通过反编译工具我们看到了，加入final后，堆内存直接存储的是值，而不是变量名。
	(7)匿名内部类(掌握)
		A:是局部内部类的简化形式
		B:前提
			存在一个类或者接口
		C:格式:
			new 类名或者接口名() {
				重写方法;
			}
		D:本质：
			其实是继承该类或者实现接口的子类匿名对象
	(8)匿名内部类在开发中的使用
		我们在开发的时候，会看到抽象类，或者接口作为参数。
		而这个时候，我们知道实际需要的是一个子类对象。
		如果该方法仅仅调用一次，我们就可以使用匿名内部类的格式简化。
		
		interface Person {
			public abstract void study();
		}
		
		class PersonDemo {
			public void method(Person p) {
				p.study();
			}
		}
		
		class PersonTest {
			public static void main(String[] args) {
				PersonDemo pd = new PersonDemo();
				pd.method(new Person() {
					public void study() {
						System.out.println("好好学习，天天向上");
					}
				});
			}
		}
		
	(9)匿名内部类的面试题(补齐代码)
		interface Inter {
			void show();
		}
		
		class Outer {
			//补齐代码
			public static Inter method() {
				return new Inter() {
					public void show() {
						System.out.println("HelloWorld");
					}	
				};
			}
		}
		
		class OuterDemo {
			public static void main(String[] args) {
				Outer.method().show(); //"HelloWorld"
			}
		}

:接口
 (1)回顾猫狗案例，它们仅仅提供一些基本功能。
    比如：猫钻火圈，狗跳高等功能，不是动物本身就具备的，
    是在后面的培养中训练出来的，这种额外的功能，java提供了接口表示。
 (2)接口的特点：
  A:接口用关键字interface修饰
   interface 接口名 {}
  B:类实现接口用implements修饰
   class 类名 implements 接口名 {}
  C:接口不能实例化
  D:接口的实现类
   a:是一个抽象类。
   b:是一个具体类，这个类必须重写接口中的所有抽象方法。
 (3)接口的成员特点：
  A:成员变量
   只能是常量
   默认修饰符：public static final
  B:构造方法
   没有构造方法
  C:成员方法
   只能是抽象的
   默认修饰符：public abstract
 (4)类与类,类与接口,接口与接口
  A:类与类
   继承关系，只能单继承，可以多层继承
  B:类与接口
   实现关系，可以单实现，也可以多实现。
   还可以在继承一个类的同时，实现多个接口
  C:接口与接口
   继承关系，可以单继承，也可以多继承
 (5)抽象类和接口的区别(自己补齐)?
  A:成员区别
   抽象类：
   接口：
  B:关系区别:
   类与类：
   类与接口：
   接口与接口：
  C:设计理念不同
   抽象类：is a，抽象类中定义的是共性功能。
   接口：like a，接口中定义的是扩展功能。
 (6)练习：
  A:猫狗案例，加入跳高功能
  B:老师和学生案例，加入抽烟功能0