[Java速成]3. Java面向对象编程

JAVA面向对象编程

1. 封装特性:

1. 定义类：

一般情况下在一个包中定义类，一个类一个.java文件：

// Telephone.java
package com.functionD;

public class Telephone {

    static String brand;
    float screen;
    float cpu;
    float mem;

    //初始化代码块
    {
        screen = 9.7f;
        cpu = 2.5f;
        mem = 4.0f;
    }

    static {
        brand = "apple";
    }

    // 构造方法
    public Telephone(){
        System.out.println("Telephone has be created by no parameter!");
    }

    public Telephone(float screenIn, float cpuIn, float memIn){
        screen = screenIn;
        cpu = cpuIn;
        mem = menIn;
        System.out.println("Telephone has be created by parameters!");
    }

    void call (){
        System.out.println("Telephone call!");
    }

    void sendMassage() {
        System.out.println("Telephone sendMassage!");
    }
}

1. static 修饰符

   静态变量

   与c++类似，用static修饰的变量为类所有，其派生的所有对象共享。 本质就是其在内存空间中单独开辟一个区域，而不是依赖与对象的内存空间。
   

   静态方法

   静态方法也是不依赖于具体对象的方法，在内存空间中单独开辟一块区域。(其实所有方法都是这样)。
   

   注意： 1. 静态方法中可以直接调用同类中的静态属性和方法，但不能直接调用非静态属性和方法。如果希望在静态方法中调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量。

2. 初始化块

   用来初始化成员变量的一组代码；

2. 继承特性

1. 继承

   extends 关键字， java只支持单继承。

   public class Knife extends Cutlery {
       // 类的内容
   }
   

2. this 关键字

   类似于c++的this指针，python的self。 但是java中的this不那么严格， 可以不加，只要在出现歧义的时候加上就好。

3. final 关键字

   修饰类， 这个类不可以被继承

   修饰方法， 这个方法不允许被重写

   修饰属性， 这个属性必须被明确初始化值

   修饰变量， 这个变量不允许被修改， 即为常量。

4. super 关键字

   当父类的属性或方法被重写后，可通过super.属性或方法调用父类的属性或方法。

5. Object 类

   类似与python中的object类， 即java中的万物起源， 如果一个类没被明确表示继承哪个类， 就默认继承Object类

   其中包含的一些方法

   toString()方法, 类似于python object类中的__str__()方法，给System.out.println调用的方法。默认返回为内存地址，我们可以重写来显示内容。
   
   equals()方法, 用来判断另一个对象的引用是不是与自己指向同一个对象（内存空间）
   

3. 多态特性

1. 父类的引用可以指向子类对象

   同c++，父类指针可以指向其派生类的对象，不同的是，所有方法都会向下映射，c++只有虚方法才会向下映射。

   Dog dog = new Dog();
   Animal animal = dog; //类型自动向上转换
   Dog dog2 ＝ (Dog)animal； //向下类型转换需要强制符号
   Cat cat = (Cat)animal; //编译器不会报错， 执行时会报错
   

   instanceof 语句:

   if(animal instanceof Cat){
       Cat cat = (Cat)animal;
   }else{
       System.out.println("Can not change！");
   }
   

2. Abstract 关键字

   类似于c++中的vitrual关键字。专门用来给别人继承，别人继承后就必须实现抽象类中的抽象方法。

   修饰定义类： 这个类是抽象类，其不能实例化成对象。

   修饰方法： 这个方法就是抽象方法，只需要定义，不需要实现。 包含抽象方法的类自动变成抽象类。

3. interface 接口

   接口是用来规范类的定义的。接口定义：

   //接口可以多继承
   public interface 借口名 [extends 父接口1, 父接口2]{
       //0到多个常量的定义
       //0到多个方法的定义
   }  
   

   接口中的属性都是常量，系统自动添加public static final；
   接口中的方法都是抽象方法，系统自动添加public abstract;

   使用接口：

   public class 类名 [extends 父类] [implements 接口1, 接口2]{
       // 需要实现接口中的抽象方法(即所有方法)
       // 如果继承的父类为抽象类，需要实现父类中的抽象方法
   } 
   

   接口的引用可以用来指向使用了这个接口的类的对象

   InterfaceName cat = new Cat();
   cat.eat();
   

   用接口构造匿名内部类

   // Animal 是一个接口
   Animal cat = new Animal() {
       public void eat(){
           System.out.println("cat eat!");
       }
       public void travel() {
           System.out.println("cat travel!");
       }
   };
   cat.eat();