java类的种类

1.this

this指向当前对象。

public class HelloWorld{

String name = "桔子桑";

public void call(){

System.out.println(this.name);

}

}

2.java中的几种类

我们知道如何去定义一个类，在此基础上，还有子类、内部类。

class BaseClass{//父类  }

class newClass extends BaseClass{//子类   }

这个子类newClass继承了父类的所有属性和方法，并且还额外拥有自身的属性和方法。

public class Wrap {

public class InnerClass{
                    public void say(){
                               System.out.println("内部类的方法");
                    }
            }

//程序入口
            public static void main(String[] args) {
                      // TODO Auto-generated method stub
                     Wrap hi = new Wrap();//  实例化外部类
                     InnerClass hello = hi.new InnerClass();//实例化内部类，注意写法
                     hello.say();
             }
   }

以上就是如何定义（成员）内部类以及调用。

3.内部类的种类

成员内部类：上一条所提到的内部类就是成员内部类，所谓成员内部类，

就是说这种类的级别同等于成员变量和方法，它们是属于同一级别的；

作为一个类，它是可以有自己内部的变量和方法的，成员内部类内部也是可以定义变量和方法的；

内部类访问外部类的变量，采用 外部类名.this.外部类成员变量名，例如：OuterClass.this.name;

外部类方法访问内部类变量或者方法，采用OuterClass  outer = new OuterClass();

                         InnerClass inner =outer.new InnerClass();获取内部类对象，

然后inner.name;或者inner.say();访问变量和方法。

静态内部类：静态内部类就是一般的内部类加上static修饰符；

因为是静态的，所以只能直接访问静态变量和方法，这一点java学习笔记03第5条讲到过，

不记得的可以再回顾一下；

要访问非静态变量和方法，要先实例化一个变量所在类的实例，然后再通过 实例.静态变量名 访问。

方法内部类：就是内部类定义在外部类的方法中；

方法内部类只能在该方法内部使用，所以不能使用访问控制符（public等）和修饰符（static）；

就像是局部变量，在方法外部是无法访问的。

4.类的继承

上面所说的子类实际上就是类的继承；

采用extends关键字，子类继承了父类的属性和方法；

如果子类对于父类的方法不满意，可以修改方法，但是定义方法的形式不可作任何更改，即方法重写。

创建子类对象时，初始化顺序为：父类属性初始化-->父类构造方法-->子类属性初始化-->子类构造方法。

5.super的使用

super指向该子类的父类对象，相当于为我们简化了实例化父类对象的步骤；

BaseClass  base = new BaseClass();这个super就相当于这里的base；

base.name和super.name是等价的。

6.Object类

java中所有我们自己定义的类其实都有一个相同的父类，那就是Object类；

所以我们定义的类都具有Object类的方法和属性，例如：toString()方法、equals()方法，当然，

我们是可以在自定义类中对这些方法进行修改以达到自己想要的效果。

7.多态

多态是建立在继承的基础上的，现在有一个父类Father和一个子类Son；

它们都有一个同名方法say()，当然内容不一样，可以看做是子类对父类的方法重写；

另外Son还有一个自己独有的方法hi();

Father father = new Father();   //父类的引用指向父类对象（引用多态）

Father son = new Son();          //父类的引用指向子类的对象（引用多态）

father.say();                              //这个语句是可行的（方法多态），访问的是父对象的方法

son.say();                                 //这个语句也是可行的（方法多态），访问的是子对象的方法

son.hi();                                    //这个语句是不可行的

总结：只有在某种方法（方法体可以不同）同时存在于引用类和对象类的前提下，

才能对其进行调用。

8.引用类型转换

引用类型转换分为向上转换、向下转换；依旧使用上面的例子

Son son1 = new Son();                  //子类的引用指向子类的对象

Father son2 = son1;                      //父类的引用指向子类的对象，这里的son就相当于new Son();

这种父类的引用指向子类的对象就是向上类型转换；

   可以这么理解，子类是继承于父类的，它可以人为地添加一些父类没有的属性或方法，

所以，子类的容积是大于父类的，那么现在将父类的引用（一碗水）放到/指向子类的对象（一桶水），

是不存在任何问题的，所以向上类型转换是不存在任何问题的。

Son son3 = son2;                          //子类的引用指向采用父类引用的对象，可以看到son2是采用了父类的引用

这种子类的引用指向采用父类引用的对象就是向下类型转换；

虽然这个对象是一个子类对象，但是它采用了父类的引用，编译器认为这种引用类型转换是存在风险的，

要解决这个问题，就要人为地将这个对象声明为子类引用（强制转换）；

Son son3 = (Son)son2;

instanceof,返回值为布尔型，检验两者是否是同一个对象，即是否能够真正实现强制转换；

Father son4 = new Father();

son1是一个采用Son类引用的Son对象；

son2是一个采用Father类引用的Son对象；

son4是一个采用Father类引用的Father对象；

son2 instanceof Son；因为son2是个Son对象所以返回值为True，Son son3 = (Son)son2这种强制转换是有效的；

son4 instanceof Son；因为son4是个Father对象，所以该返回值为False，Son son3 = (Son)son4这种强制转换是无效的。

9.抽象类

定义一个抽象类采用abstract关键字；

public abstract class Father{

public abstract void call();

public abstract void say();

}

抽象类内的方法也采用abstract关键字，且没有方法体；

继承（extends）了抽象类的子类会自动创建抽象类内部的方法。

10.接口Interface

接口可以理解为一个特殊的抽象类，习惯在命名上以大写的 I 字母打头；

public abstract interface Itodo{

public abstract void call();

}

接口中的abstract关键字我们通常是不用写明的，虽然不写但系统会帮我们自动添加的；

那如何为一个类实现接口的功能呢，这里采用implements关键字；

public class Son extends Father implements Itodo{

@Override

public  void call(){

// TODO Auto-generated method stubs

System.out.println("该类继承了Father类并实现接口Itodo");

}

}

Father类和接口Itodo之间并无任何联系。