黑马程序员_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         抽象修饰符：abstractB:类：         权限修饰符：默认修饰符，public         状态修饰符：final         抽象修饰符：abstract         用的最多的就是：publicC:成员变量：         权限修饰符：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类名或者接口名(){                            重写方法;                   }本质:是一个继承了该类或者实现了该接口的子类匿名对象。