面向对象

2016-10-19  本文已影响0人  A_Coder

1.面向对象的主要特征

2.继承和组合
组合式指在新类里面创建原有类的对象，重复利用已有类的功能。继承允许设计人员根据其他类的实现来定义一个类的实现。组合都允许在新的类中设置子对象。组合和继承存在着对应关系：组合中的整体类和继承中的子类对应，组合中的局部类和继承的父类对应。
二者区别：如，Car表示汽车对象，Vehicle表示交通工具对象，Tire表示轮胎对象。Car是Vehicle的一种，因此是一种继承关系（又被称为"is - a"关系）；而Car包含了多个Tire，因此是一种组合关系（又被称为"has - a"关系）：

继承 组合
class Vehicle{}
class Car extends Vehicle{}		 class Tire{}
class Car extends Vehicle{
private Tire t = new Tire();
}

选择：

3.多态的实现机制
表示当同一个操作作用在不同对象时，会有不同的语义，从而会产生不同的结果。多态主要有两种表现方式：

class Base{
    public Base() {
        g();
    }
    public void f(){
        System.out.println("Base f()");
    }
    public void g(){
        System.out.println("Base g()");
    }
}
class Derived extends Base{

    public void f(){
        System.out.println("Derived f()");
    }
    public void g(){
        System.out.println("Derived g()");
    }
}
public class Test{
  
    public static void main(String []args){
        Base b = new Derived();
        b.f();
        b.g();
    }
}

程序运行结果是：
Derived g()
Derived f()
Derived g()

注：只有类中的方法才有多态的概念，类中成员变量没有多态的概念。成员变量的值取决于所定义变量的类型，这是在编译期间确定的

注意：

重载和覆盖的区别：

注：函数是不能以返回值来区分的，虽然父类和子类中的函数有着不同的返回值，但是它们有着相同的函数名，因此，编译器无法区分。

4.抽象类和接口的异同
在Java语言中，可以把类或类中的方法声明为abstract（只能修饰类或方法，不能修饰属性）来表示一个类是抽象类。接口是指一个方法的集合，接口中的所有方法都没有方法体，通过关键字interface来实现。

接口与抽象类的不同点：

注：

5.内部类
主要有4种：静态内部类、成员内部类、局部内部类、匿名内部类。

5.this与super区别
在Java语言中，this用来指向当前实例对象，它的一个非常重要的作用就是用来区分对象的成员变量与方法的形参。（如：this.name = name）。
super可以用来访问父类的方法或成员变量。当子类的方法或成员变量与父类有相同的名字时也会覆盖父类的方法或成员变量，要想访问父类的方法或成员变量只能通过super关键字来访问。

注：当子类构造函数需要显示调用父类构造函数时，super()必须为构造函数中的第一条语句。

6.continue、break、return

public class Break {
    public static void main(String args[]){
        out:
        for(int i = 0;i < 5; i++) {
            for(int j=0;j<5;j++) {
                if(j>=2) {
                    break out;
                    System.out.println(j);
                }
            }
        }
    }
}

7.final、finally、finalize

final方法：当一个方法声明为final时，该方法不允许任何子类重写这个方法，但子类仍然可以使用这个方法。另外，有一种称为inline（内联）机制，当调用也给被声明为final的方法时，直接将方法主体插入到调用处，而不是进行方法调用，这样提高程序效率。
final参数：用来表示这个参数在这个函数内部不允许修改。
final类：当一个类被声明为final时，此类不能被继承，所有方法不能被重写（覆盖）。但是要想final类的成员变量不可改变，必须给成员变量增加final修饰，不然可以改变。一个类不能被声明为final，同时又被声明为final。

8.断言assert
它的作用是对也给boolean表达式进行检查，一个正在运行的程序必须保证这个boolean表达式的值为true，若boolean表达式的值为false，则说明程序已经处于一种不正确的状态下，系统需要提供告警信息并且退出程序。一般在调试程序时使用。
有两种表达式：1.assert expression1 与 assert expression1 : expression2，其中，expression1表示一个boolean表达式，expression2表示一个基本类型或者是一对象，基本类型包括：boolean、char、double、float、int和long。

public class Test { 
    public static void main(String []args){
        assert 1 + 1 == 2;
        System.out.println("assert1 ok");
        assert 1 + 1 == 3 : "assert faild,exit."
        System.out.println("assert2 ok");
    }
}

当执行指令java -ea Test时，程序的输出结果为：
assert1 ok
Exception in thread "main" Java.lang.AssertionError:assert faild,exit at Test.main(Test.java:5)

应用范围包括：

9.static关键字
主要有两种作用：第一，为某种特定数据类型或对象分配单一的存储空间，而与创建对象的个数无关。第二，实现某个方法或属性与类而不是对象关联在一起，即在不创建对象的情况下就可以通过类来直接调用方法或使用类的属性。

class Singleton{
    private static Singleton instance = null;
    private Singleton() {}
    public static Singleton getInstance(){
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

用public修饰的static变量和方法本质上都是全局的，若在static变量前用private修饰，则表示这个变量可以在类的静态代码块或者类的其他静态成员方法中使用，但是不能在其他类中通过类名来直接引用。

值传递与引用传递

public class Test{
    public static void changeStringBuffered(StringBuffer ss1, StringBuffer ss2) {
        ss1.append(" world");
        ss2 = ss1; //ss1的地址赋值给ss2了
    }
    public static void main(String []args){
        Integer a = 1;
        Integer b = a;
        b++;
        System.out.println(a);
        System.out.println(b);
        StringBuffer s1 = new StringBuffer("Hello");
        StringBuffer s2 = new StringBuffer("Hello");
        changeStringBuffered(s1, s2);//把s1、s2的地址传递给形参ss1、ss2
        System.out.println(s1);
        System.out.println(s2;
    }
}

程序运行结果为：
1
2
Hello World
Hello //因为s2的值没变，只是ss2的地址指向s1的了

上一篇下一篇

猜你喜欢

热点阅读