JAVA基础复习与总结<一> 对象与类的概念_内部类_继承与多态

一、对象与类

类：类是一个模版，它描述了一类对象的行为和状态。

    class animal {
    private int color;
    private int size;

    public void eat () {
        System.out.println("I'm eating!");
    }

    public void sleep () {
        System.out.println("I'm sleeping!");
    }
}

       上面一段代码就定义了一个animal类，它在内部规定了一类对象段状态/属性（color,size）等。同时还规定了它可以进行什么样的动作（eat,slepp）。

 

       对象：对象是由类延伸开来的，具有类里面描述的状态/属性，同时可以进行类里已经规范好的行为的一个具体的个体。也可以说，类是规范而对象是实体。

public static void main(String[] args) {

    animal dog = new animal();
    dog.eat();
}

二、内部类（innerclassses）

     一般情况下，我们把类定义成为独立的单元。有些情况下，我们把一个类放在另一个类的内部定义，称为内部类。内部类包括四种类型：成员内部类、局部内部类、匿名内部类、静态内部类。

    1、成员内部类

    class animal {
    private int color;
    private int size;

    class animalbehavior{
        public void eat () {
            System.out.println("I'm eating!");
        }

        public void sleep () {
            System.out.println("I'm sleeping!");
        }

    }
}

 

    像上面的代码就把动物的行为单独封装成一个animalbehavior类，它属于animal的成员内部类。而animal就是外部类。成员内部类可以无条件访问外部类的所有成员属性和成员方法，包括私有和静态。

    1）当成员内部类和外部类具有相同的成员变量或者方法时会发生隐藏现象，就出现默认访问成员内部类的成员。要想在成员内部类中访问外部类的同类成员，需要下面的格式：

外部类.this.成员变量 外部类.this.成员方法

2）外部类想要访问成员内部类的成员，必须先创建一个成员内部类对象，再通过指向这个对象的引用来访问。

class animal {
private int color;
private int size;

public animal(int color ,int size){
    this.color =color;
    this.size = size;
    getBehavior().eat();
    getBehavior().sleep();              //外部类必须要通过成员内部类的对象来访问内部类的成员

}

private animalbehavior getBehavior(){   //通过这个方法得到了一个内部类对象
    return new animalbehavior();        //内部类
}

public class animalbehavior{
    public void getColor(){
        System.out.println(color);   //内部类可以直接访问外部类的成员
    }
    public void eat () {
        System.out.println("I'm eating!");
    }

    public void sleep () {
        System.out.println("I'm sleeping!");
    }

}

    3）成员内部类是依附外部类存在的，想要创建成员内部类对象，前提是要先创建一个外部类对象。       

    4）成员内部类（可以使用private、protected、public 任意进行修饰。 类文件：外部类$内部类.class）。但是外部类只能被public或者protected修饰。

 

 

    2、局部内部类

    局部内部类是定义在一个方法或者一个作用域里面的类。作用域只限于本方法或者本作用域。用的非常少。 局部内部类不能有public、protected、private以及static修饰。

  

    3、匿名内部类

    适合那种只需要使用一次的类。比如“键盘监听操作”等等。语法：

             new 父类构造器（实参类表）实现接口( ) {

                   //匿名内部类类体

          }

 

    4、静态内部类

     静态内部类也是在类的内部定义，但是要在类的前面加上关键字static。静态内部类并不依赖于外部类，也就是说可以不用先定义外部类对象而可以直接定义内部类对象。静态内部类不能使用外部类的非static成员变量或者方法。

 

 

    内部类的作用：

         1、内部类提供了更好的封装。只能让外部类直接访问，不允许同一个包的其他类直接访问。

         2、内部类可以直接访问外部类的私有属性，内部类被当成其外部类的成员。但外部类不能访问内部类的内部属性。

 

 

 

    内部类的使用场合：

        由于内部类提供了更好的封装特性，并且可以很方便的访问外部类的属性。所以，通常内部类在只为外部类提供服务的情况下优先使用。

 

 

三、继承与多态

        

继承的关键字是：extends，是所有面向对象语言的重要特性。

例public class TestExtends {

    public static void main(String[] args){
        Student stu = new Student();
        stu.name = "kk";
        stu.height = 172;
        stu.rest();

        Student stu2 = new Student("xx",150,"Science");

    }
}

class Person{
    String name;
    int height;
    public void rest(){
        System.out.println("休息一会儿！");
    }

}

class Student extends Person{
    String major;

    public void study(){
        System.out.println("学习俩小时！");
    }
    public Student(){};
    public Student(String name,int height,String major){
        this.name = name;
        this.height = height;
        this.major = major;
    }
}

      在上例子中我们首先定义了一个Person类，这是一个父类。而之后又定义了一个Student类，Student属于从父类Person中派生出的子类。

当两个类存在继承关系当时候，子类会自动继承父类的属性和方法，那么子类中还可以使用父类的属性和方法。在JAVA中只允许单继承，一个子类只能有一个父类，但是一个父类却可以派生出多个子类。

子类不仅仅继承了父类的属性与方法，还可以发挥出自己的“特长”。比如在父类Person中我们定义了一个简单的“人”，这个类中包含基本信息有名称name和身高height。这个抽象的“人”可以完成的动作是休息rest。

而从一个抽象的人派生出的子类Student就更加具体了。简单来说子类就是把父类更加细化和丰满的一个过程。从Person中诞生了Studnet，Student毫无疑问当然是Person的一员。但是Student却具有着Person大众所不具有的属性（代码段中并未展开），比如学号，比如成绩单等。这样我们就从一个抽象概念的人中拿出了一个有血肉的个体概念。

引入了Person类以后我们还可以从Person类中派生出Teacher、Parent等子类，这样所有子类就可以共用到Person类的属性与方法。在同一个具体项目之中，互相有联系的对象都是从同一个父类中派生出来的，这样有助于规范代码，同时节省操作量。

 

    注意：

    1、Java只有一个单继承，没有C++单多继承。

    2、Java中类没有多继承，接口有多继承。

    3、子类继承父类，可以得到父类的全部属性和方法（除了父类的构造方法）

    4、如果定义一个类时，没有调用extends，则它的父类是：java.lang.Object。  

    5、instanceof运算符：

    instanceof是二元运算符，左边是对象，右边是类；当对象是右面类或子类所创建的对象时，返回true；否则返回false。比如：System.out.println(s instanceof person); 

规范：

　1、针对属性

1）子类能够继承父类的public和protected成员变量，并不能继承父类的private成员变量。

2）对于父类的包访问权限成员变量（default，如果不加权限修饰符就默认为default），必须当子类与父类在同一包下才能继承，否则子类不能继承。

3）当子类中出现与父类同名的成员变量时时候，父类的成员变量会被隐藏。即在调用子类对象时候出现的是子类的成员变量。如果要在子类中访问父类的同名成员变量，需要用super关键字来引用。

2、针对方法

     1）同上述针对属性--->1)

2）同上述针对属性--->2)

3）如果在子类中出现了与父类同名的成员方法，则子类方法会把父类方法覆盖掉。要调用父类同名方法则要使用super关键字。（这一点很方便的是，可以仅仅在父类中写一个概念性的空方法，而在每个具体子类中对这个空方法根据子类对象具体特点来重写。）

3、针对构造器

子类不能够继承父类的构造器。但是当父类当构造器带有参数时，子类构造器中必须现实通过调用super关键字来调用父类哦构造器并且配上适当的参数列表。如果父类构造器无参，则不需要用super调用父类构造器。如果没有使用super，则系统会自动调用父类的无参构造器。

多态

   多态指的是同一个方法调用，由于对象不同可能会有不同的行为。现实生活中，同一个方法，具体实现会完全不同。

   多态的要点：

      1、多态是方法的多态，不是属性的多态（多态与属性无关）。

      2、多态的存在要有三个必要条件：继承、方法重写、父类引用指向子类对象。

      3、父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了。 

public class Animal {
    String str;
    public void voice(){
        System.out.println("普通动物叫声！");
    }
}

class Cat extends Animal {
    public void voice(){
        System.out.println("喵喵喵");
    }
    public void catchMouse(){
        System.out.println("抓老鼠");
    }
}

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

    public void seeDoor(){
        System.out.println("看门！");
    }

}