黑马程序员_java基础之面向对象多态及内部类

------- android培训、java培训、期待与您交流！ ----------

1.多态的概述及其代码体现
A:多态概述:    事物存在的多种形态
B:多态前提:    a:要有继承关系。
                            b:要有方法重写。
                            c:要有父类引用指向子类对象。
多态中的成员访问特点
A:多态中的成员访问特点
         a:成员变量
                    编译看左边，运行看左边。
b:成员方法
                    编译看左边，运行看右边。
         c:静态方法
                    编译看左边，运行看左边。
                    (静态和类相关，算不上重写，所以，访问还是左边的)
面向对象(多态的好处和弊端)
A:多态的好处          a:提高了代码的维护性(继承保证)
                                     b:提高了代码的扩展性(由多态保证)
C:多态的弊端:         不能使用子类的特有功能。

	public static void main(String[] args){
		Student s = new BaseStudent();
		s.setName("小李");
		s.setId(23);
		s.show();
		s.study();
	System.out.println("--------");
		Student s1 = new BaseStudent("名誉",25);
		s1.show();
		s1.study();
	}
}
abstract class Student {
	private String name ;
	private int id ;
	
	public Student(){}
	public Student(String name,int id){
		this.name = name;
		this.id = id;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String name(){
		return name;
	}
	
	public void setId(int id){
		this.id = id;
	}
	public abstract void study();
	public  void show(){
		System.out.println(name + id);
	}
}
class BaseStudent extends Student {
	public BaseStudent(){}
	public BaseStudent(String name,int id){
		super(name,id);
	}
	public void study(){
		System.out.println("学习JAVA基础");
	}
}
class WorkStudent extends Student {
	public WorkStudent(){}
	public WorkStudent(String name,int id){
		super(name,id);
	}
	public void study(){
		System.out.println("学习JAVA就业");
	}
}
2.抽象类的特点
抽象类特点
         a:抽象类和抽象方法必须用abstract关键字修饰
                   abstractclass 类名 {}
             public abstract void eat();
         b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
         c:抽象类不能实例化那么，抽象类如何实例化呢?
                   按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
         d:抽象类的子类
                   要么是抽象类
                   要么重写抽象类中的所有抽象方法
抽象类的成员特点
         a:成员变量：既可以是变量，也可以是常量。
         b:构造方法：有。
                   用于子类访问父类数据的初始化。
         c:成员方法：既可以是抽象的，也可以是非抽象的。
抽象类的成员方法特性：
         a:抽象方法强制要求子类做的事情。
         b:非抽象方法子类继承的事情，提高代码复用性。
面试题1
         一个抽象类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
         可以,这么做目的只有一个,就是不让其他类创建本类对象,交给子类完成
面试题2
         abstract不能和private ,finl ,static关键字共存
	int num = 10;
	public abstract void show();
}
//抽象类是不能被实例化的,所以不能Person p = new Person();
class PersonDemo {
	public void method(Person p) {					//Person p = new Demo()
		p.show();
	}
}
class PersonTest {
	public static void main(String[] args) {
		//如何调用PersonDemo中的method方法呢?
		PersonDemo pd = new PersonDemo ();
		/*pd.method(new Person() {					//匿名内部类当作参数传递
			public void show() {
				System.out.println("show");
			}
		});*/
		pd.method(new Demo());						//也可以定义有名字的类继承Person
	}
}
class Demo extends Person {
	public void show() {
		System.out.println("show");
	}
}
3.接口的概述及其特点
接口概述
         从狭义的角度讲就是指java中的interface
         从广义的角度讲对外提供规则的都是接口
接口特点
         a:接口用关键字interface表示:    interface 接口名 {}
         b:类实现接口用implements表示:        class 类名 implements 接口名 {}
         c:接口不能实例化 :        按照多态的方式来实例化。
         d:接口的子类
                   a:可以是抽象类。但是意义不大。
                   b:可以是具体类。要重写接口中的所有抽象方法。(推荐)
接口成员特点
         成员变量；只能是常量，并且是静态的。
                            默认修饰符：public static final
                            建议：自己手动给出。
         构造方法：接口没有构造方法。
         成员方法：只能是抽象方法。
                            默认修饰符：public abstract
                            建议：自己手动给出。
4.面向对象(类与类,类与接口,接口与接口的关系)
A:类与类,类与接口,接口与接口的关系
         a:类与类：
                   继承关系,只能单继承,可以多层继承。
         b:类与接口：
                   实现关系,可以单实现,也可以多实现。
                   并且还可以在继承一个类的同时实现多个接口。
         c:接口与接口：
                   继承关系,可以单继承,也可以多继承。
面向对象(抽象类和接口的区别)
 A:成员区别
          抽象类：
                  成员变量：可以变量，也可以常量
                   构造方法：有
                   成员方法：可以抽象，也可以非抽象
         接口：
                   成员变量：只可以常量
                   成员方法：只可以抽象        
B:关系区别
         类与类:   继承，单继承
         类与接口:        实现，单实现，多实现
         接口与接口:   继承，单继承，多继承
C:设计理念区别
         抽象类被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。
         接口被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。
导包格式:        import 包名;
                            注意：     这种方式导入是到类的名称。
	public static void main(String[] args) {
		Outer o = new Outer();
		o.method();
	}
}
//匿名内部类
interface Inter {
	public void print();
}
class Outer {						//这是外部类
	/*class Inner implements Inter{					//这是内部类
		public void print() {
			System.out.println("Hello World!");
		}
	}
	public void method() {
		//Inner i = new Inner();						//直接创建子类对象
		//i.print();
		new Inner().print();
		Inter i2 = new Inner();						//父类引用指向子类对象
		i2.print();
	}*/
	//匿名内部类
	public void method() {
		/*
		new 接口或类(){		实现这个接口或继承这个类
			写需要重写的方法
		}
		*/
		new Inter(){									//整个代表Inter的子类对象
			public void print() {
				System.out.println("Hello World!");
			}
		}.print();										//调用重写后的方法
	}
}
5.四种权限修饰符
                   本类         同一个包下(子类和无关类)         不同包下(子类)       不同包
                   private            Y               
                   默认                   Y                Y
                   protected                  Y                Y                                                               Y
                   public                 Y                Y                                                               Y                                   Y
面向对象(类及其组成所使用的常见修饰符)
A:修饰符：
         权限修饰符：private，默认的，protected，public
         状态修饰符：static，final
         抽象修饰符：abstract
B:类：
         权限修饰符：默认修饰符，public
         状态修饰符：final
         抽象修饰符：abstract
         用的最多的就是：public
C:成员变量：
         权限修饰符：private，默认的，protected，public
         状态修饰符：static，final
         用的最多的就是：private    
D:构造方法：
         权限修饰符：private，默认的，protected，public
         用的最多的就是：public       
E:成员方法：
         权限修饰符：private，默认的，protected，public
         状态修饰符：static，final
         抽象修饰符：abstract
         用的最多的就是：public       
F:除此以外的组合规则：
         成员变量：public static final
         成员方法：
                   publicstatic
             public abstract
                   *public final
6.内部类访问特点
          a:内部类可以直接访问外部类的成员，包括私有。
          b:外部类要访问内部类的成员，必须创建对象。
                   外部类名.内部类名 对象名 = 外部类对象.内部类对象;
静态成员内部类
成员内部类被静态修饰后的访问方式是:
                  外部类名.内部类名 对象名 = 外部类名.内部类对象;
7.局部内部类访问局部变量必须用final修饰
         因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用
8.匿名内部类的格式
匿名内部类:   就是内部类的简化写法。
前提：存在一个类或者接口
                   这里的类可以是具体类也可以是抽象类。
格式：
                   new类名或者接口名(){
                            重写方法;
                   }
本质:是一个继承了该类或者实现了该接口的子类匿名对象。