java面向对象

一丶面向对象

万物皆对象

描述一个物质都可以通过两方面说明：数据模型（属性）、行为模型（行为）。

在Java编程中，我们使用成员变量表示数据模型，用成员方法表示行为模型。

使用类表示某些具有相同属性和行为的事物。

以动物为例：

1、构造方法

语法：

[访问修饰符] 类名(){

 

}

注意：

当类中没有显式的构造方法，实例化该类的对象时，程序会自动创建一个公开的无参构造方法；

如果类中有显示的构造方法，程序就不会创建无参构造；

构造方法，一般是用于为成员属性赋初始化值；

2、变量

2.1 局部变量

Ø  声明在构造方法、静态方法、实例方法、代码块中的变量，都是局部变量；

Ø  不能使用static和访问修饰符修饰；

Ø  可以使用final修饰，即为常量，不必在声明语句中赋值；

Ø  当执行局部变量所在的方法或代码块时，才有机会被创建，在方法或代码块执行结束后被自动销毁；

Ø  局部变量在内存的栈区分配；

Ø  局部变量在使用之前必须要先赋值；

2.2 实例变量

Ø  声明在所有方法体和代码块之外，并且没有使用static修饰的变量，叫做实例变量；

Ø  可以使用访问修饰符和final修饰；

Ø  使用final修饰时，一定要赋值；

Ø  实例变量是在对象被创建时创建，对象被销毁时销毁；

Ø  作用域范围在整个类中；

2.3 类的变量

Ø  声明在所有方法体和代码块之外，并且使用static修饰的变量；

Ø  可以使用访问修饰符修饰；

Ø  一般配合final使用，即public  static fianl，标识符使用大写；

Ø  类变量被分配在静态存储区，是被所有该类的对象共享数据；

Ø  类变量是在程序开始时被创建，程序结束时销毁；

3、访问修饰符

访问修饰符是用来控制其他类对该类的类、实例变量、构造方法、实例方法的访问权限。Java的访问权限有4种：

public 公开的

protected 受保护的

默认的，没有任何关键字来表示

private 私有的

 

修饰符

当前类

同包的类

同包的子类

异包

异包的子类

public

√

√

√

√

√

protected

√

√

√

×

×

默认的

√

√

√

×

×

private

√

×

×

×

×

 

4、this关键字

this指当前对象，用法：

Ø  当局部变量名和实例变量名同名时，使用this.变量名来表示实例变量；

Ø  this()表示当前类的构造方法，只能在构造方法中使用该写法，并且是写在构造方法内的第一行。

5、封装

私有的属性，公开的方法。

封装的步骤：

声明私有（private）的属性；

声明公开（public）的geter和seter方法；

6、继承

Java中的继承是单继承，可以实现多层继承，继承的关键字extends

语法：

public classSon extendsFather{

 

}

规则：

Ø  子类继承父类非私有的所有属性和方法，不能继承父类的构造方法；

Ø  实例化子类对象的步骤：先执行父类的构造方法，再执行子类的构造方法；

重写定义：

Ø  子类重新声明从父类继承来的方法，称为方法重写；

Ø  方法重写时，方法的声明部分要和父类保持一致（返回值类型，方法名，参数）；

Ø  重写方法的访问权限要大于等于父类中方法的访问权限；

Ø  子类重写父类方法，子类对象调用的是子类中重写后的方法；

Ø  使用static修饰的方法不能被重写，但是可以被子类重写声明；

Ø  不同包的子类可以重写父类中protected修饰的方法，但是不能以继承的形式，用子类对象直接调用父类的该方法；

Final关键字：

Ø  当final修饰类时，当前类不能被继承；

Ø  当final修饰方法时，该方法不能被重写；

Ø  当final修饰变量时，变量的值不能被修改，即为常量；

7、多态

实现的必要条件：

Ø  继承

Ø  重写

Ø  父类引用指向子类对象

 

instanceof关键字：

语法：

if (对象名instanceof 类名) {   

      类型转换代码；

}

实例：

Animal cat = new Cat();

      if (catinstanceof Cat) {//返回结果为boolean类型

        Cat c = (Cat) cat;

         c.eat();

      }else{

        System.out.println("类型不匹配");

      }

 

8、抽象类

抽象类语法：

public abstractclassDemo {

 

}

抽象方法语法：

publicabstractvoidabc();

 

规则：

含有抽象方法的类，一定是抽象类；

Ø  抽象类中可以声明成员变量、常量、成员方法、抽象方法，抽象类中不一定要有抽象方法；

Ø  抽象类不能被实例化；

Ø  抽象类可以被继承；

Ø  可以通过两种方式获得抽象类对象：父类引用指向子类对象、匿名内部类；

Ø  子类必须重写抽象父类的所有抽象方法，或者是把子类也定义为抽象类；

Ø  如果一个类继承的抽象父类还有上级抽象父类，那么子类中需要要重写所有抽象父类的所有抽象方法；

Ø  抽象类也可以继承非抽象类，同时继承了父类的所有非私有的属性和方法；

 

9、接口

语法：

public interfaceITest {

 

}

规则：

Ø  接口使用interface关键字修饰；

Ø  接口是一个完全抽象的抽象类；

Ø  接口中没有构造方法；

Ø  接口不能被实例化对象；

Ø  接口中可以声明静态常量、抽象方法、静态方法；

Ø  接口中不能声明实例方法，声明抽象方法时，不能使用static关键字修饰；

Ø  声明接口语句中，默认含有abstract关键字，抽象方法中也默认含有abstract关键字；

Ø  接口可以被实现，使用implements关键字，一个类实现一个接口，必须重写该接口中所有的抽象方法；

Ø  一个类可以实现多个接口，每个接口名用英文的逗号隔开，该类中必须重写所有已实现接口中的抽象方法；

Ø  接口可以继承接口，接口与接口间是多继承关系，接口不能继承类；

 

 

 

 

 

10、内部类

10.1 成员内部类

成员内部类声明在类中，方法体、代码块之外。和成员变量、成员方法在同一级别。

语法：

public class Out {

    //成员内部类

    public class Inner{

    }

}

 

实例化成员内部类：

     //先实例化外部类

     Out o = new Out();

     //使用外部类对象，再实例化内部

     Out.Inner inner = o.new Inner();

实例：

public class Out {

  //成员变量

  public int a = 1;

 

  //成员内部类

  public class Inner{

     public int a = 2;

     //内部类的成员方法

     public void print(){

//执行内部类中的实例变量a

       System.out.println(a);

//执行外部类的实例变量a

       System.out.println(Out.this.a);   

}

  }

}

 

10.2 静态内部类

声明的位置参考成员内部类。

语法：

public class Out {

  //静态内部类

  public static class Inner{

    

  }

}

实例化静态内部的对象：

Out.Inner inner = new Out.Inner();

 

实例：

public class Out {

  public static int a = 1;

  public int b = 3;

  //静态内部类

  public static class Inner{

     public static int a = 2;

     public static void print(){

       //执行静态内部的静态变量

       System.out.println(a);

       //执行外部类的静态变量

       System.out.println(Out.a);

       //执行外部类的实例变量

       Out o = new Out();

       System.out.println(o.b);

     }

  }

}

 

10.3 局部内部类

声明在方法体或代码块内，作用域范围在方法体或代码块内。

语法：

public class Out {

  public void method(){

     //局部内部类

     class Inner{

       //局部内部类的成员方法

       public void print(){

         System.out.println("局部内部类");

       }

     }

     //实例化局部内部类

     Inner inner = new Inner();

     inner.print();

  }

}

执行局部内部类的方法：

Test类：

public static void main(String[] args) {

     Out o  = new Out();

     o.method();

}

 

10.4 匿名内部类

Ø  声明位置同局部内部类一样，前提条件：必须继承一个类或实现一个接口，匿名内部类的声明和实例化对象是同时进行的；

Ø  一般使用于获得抽象类或接口对象；

语法：

父类名/接口名 对象名 =  new 父类名/接口名(){

              //匿名内部类成员

};

实例：

父类

public class Father {

}

 

匿名内部类：

public class Out {

  public void method(){

     //匿名内部类对象

     Father f = new Father(){

    };

  }

}