本文主要是介绍「Java基础」五、面向对象 基础，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

五、面向对象 基础

1 - 面向过程 与 面向对象的区别

面向过程的语言：c

面向对象的语言：c++,java,c#

• 面向对象语言的特征
  • 面向对象是一种常见的思想，比较符合人们的思考习惯
  • 可以将复杂的逻辑简单化，增强带按摩的复用性
  • 面向对象具有抽象，封装，继承，多态等特性

2 - 类

2 - 1 类的创建

构造方法：

class Cat(){
    // 类的属性
    private String name;
    private Integer age;

    // 无参构造方法
    public Cat() {
    }
    
    // 包含一个属性的构造方法
    public Cat(String name) {
        this.name = name;
    }

    public Cat(Integer age) {
        this.age = age;
    }

    // 包含所有属性的构造方法
    public Cat(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

3 - 方法

3 - 1 对象 及 对象引用

• 创建对象的引用

Cat cat；

• 创建对象

  Cat cat = new Cat();
  

  一个引用可以指向多个对象，而一个对象可以被多个引用所指；

  // 一个引用可以指向多个对象
  Cat cat ;
  Cat cat1;
  
  // 一个对象可以被多个引用所指
  cat = new Cat("小猫",5);
  cat = new Cat("大猫",6);
  
  

3 - 2 构造方法

用于初始化对象，且只在对象创建初期调用一次

不手动创建构造方法时，JVM会为你默认添加一个无参构造器，但如果手动创建了构造方法，则JVM不会在为你创建默认的构造器，需要自己添加

没有参数类型和返回值，且名称要与类名保持一致，且构造方法可以有多个

	// 无参构造方法（默认的构造方法）
    public Cat() {
    }
    
    // 包含一个属性的构造方法
    public Cat(String name) {
        this.name = name;
    }

    public Cat(Integer age) {
        this.age = age;
    }

    // 包含所有属性的构造方法
    public Cat(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

3 - 3 方法重载

每个重载方法都有一个独一无二的参数列表（即数量、类型、顺序不同）

• 重载的条件
  • 在同一个类中
  • 重载方法名必须相同
  • 重载方法的参数列表必须不同
  • 仅仅返回值不同不能构成重载
  • 重载方法返回值可以相同可以不同
  • 重载是发生在编译时，因为编译器可以通过参数的类型（参数列表）来选择使用哪个方法

3 - 4 方法的重写

方法重写是针对子类和父类之间的

特征：

​ 1、重写的方法与父类保持一致，包括返回值类型，方法名，参数列表也必须一致

​ 2、子类中重写方法的访问权限不能低于父类中的访问权限

​ 3、重写方法可以用注解@Override来标注

// 父类
class Animal{
    public void Eat(String name){
        System.out.println(name + "在吃饭！");
    }
}

// 子类
class Cat extends Animal{

    @Override
    public void Eat(String name){ // 子类重写父类的Eat()方法
        System.out.println(name + "在吃饭！但它不想吃！！！" );
    }

}

4 - 初始化

• 初始化顺序

  静态属性 > 静态代码块 > 普通属性 > 普通代码块 > 构造函数

  静态属性与静态代码块在程序启动后均只执行一次

  1. 静态属性：static修饰的属性
  2. 静态方法块：static{}包起来的代码块
  3. 普通属性：非static修饰的属性
  4. 构造代码块：用{}包裹起来的代码
  5. 构造函数：类名相同的方法
  6. 方法：普通的方法

  public class Main {
      public static void main(String[] args) {
          Text text  = new Text();
      }
  }
  class Text{
      // 静态属性
      public static String staticFiles = getStaticFiles();
  
      // 普通属性
      public String files = getFiles();
  
      // 静态代码块
      static {
          System.out.println("静态代码块！");
      }
      
      // 构造代码块
      {
          System.out.println("普通方法块");
      }
  
      // 构造方法
      public Text() {
          System.out.println("构造方法初始化");
      }
  
      public static String getStaticFiles(){
          System.out.println("静态属性！");
          return "---staticFiles---";
      }
  
      private String getFiles() {
          System.out.println("普通属性！");
          return "---files---";
      }
  }
  

5 - 对象的销毁

• java虽然是基于C++的一门高级语言，但 java 与 c/c++ 的不同的重要特征就是不需要手动的管理对象的销毁工作，而是java虚拟机进行管理和销毁的。

6 - this 和 super

this和super均是java中的关键字

this表示当前对象，有3个作用：

​ 调用方法、调用属性、调用对象本身

// 指向当前对象
public class Apple {
    int num =0;

    public Apple eatApple(){
        num++;
        return this; // 返回当前对象
    }

    public static void main(String[] args) {
        Apple apple = new Apple();
        // 由于this的原因,eatApple()可以重复调用，哪个对象调用eatApple()方法，都会返回对象本身
        apple.eatApple().eatApple(); 
    }
}

// 修饰属性，通常用于构造方法
public class Apple {
    int num =0;

    public Apple(int num){
        this.num = num;

    }

    public static void main(String[] args) {
        Apple apple = new Apple(20);
        System.out.println(apple.num);// 此时num=20

    }
}

this()方法必须放在构造方法第一句，否则编译不通过

// 与构造方法一起使用，充当全局关键字
public class Fruit {
    int num ;
    String fruit;


    public Fruit(int num){
        this(num,"苹果");
    }


    public Fruit(int num,String fruit){
        this.num = num;
        this.fruit = fruit;
    }

    public static void main(String[] args) {
        Fruit apple = new Fruit(20);
        
        System.out.println(apple.num+ "个" +apple.fruit);

    }
}

super与this功能类似，不同的是super操作的对象是父类

这篇关于「Java基础」五、面向对象 基础的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！