java进阶面向对象[一]

面向对象详解

借鉴java核心技术，一个宝藏教程

1.类和对象

对象是类的一个实例，它具有状态和行为
类是一个模版，它定义一类对象

public class dog {
  string name;
  int size;
  String color;
  int age;
  void run{

  }
  void eat{

  }
  void sleep{
    
  }
}

2.封装

封装：
Java中的封装（encapsulation）是指将类的实现细节隐藏起来，仅对外暴露必要的接口，从而实现了信息的隐藏和保护。

封装通过访问控制修饰符来实现，Java中有四种访问控制修饰符：public、protected、default和private。

public修饰符表示公开，可以被类的内部、外部和子类访问；
protected修饰符表示保护，可以被类的内部和外部子类访问；
default表示包访问权限，仅限于同一包内的访问；
private修饰符表示私有，仅限于本类内部访问。

//封装一个game类
package Game;

import java.util.Random;

public class game {
    private String name;
    private int hurt;
    private int blood;

    public void setname(String name){
        this.name=name;
    }
    public String getName(){
        return this.name;
    }
    public int getBlood(){
        return this.blood;
    }
    public void setblood(int blood){
        this.blood=blood;
    }
    public game(String name, int blood){
        this.name=name;
        this.blood=blood;
        Random random = new Random();
        this.hurt = random.nextInt(20);
    }
    public void attack(game Game)
    {
        System.out.println(this.name+"使用了庐山升龙霸对"+Game.name+"造成了"+this.hurt+"的伤害");
        Game.blood=Game.blood-this.hurt;
        if(Game.blood<0)
        {
            Game.blood=0;
        }
        System.out.println(Game.name+"剩下了"+Game.blood+"点");

    }

}

总结：
类与对象是Java中面向对象的两个重要概念。类是一种抽象数据类型，用于描述具有相同属性和行为的对象集合，它是创建对象的模板。对象则是类的一个实例，具有自己的状态（属性）和行为（方法）。

    在Java中，封装是指使用访问控制符限制类内部的数据和方法的访问范围，从而保证程序的安全性和健壮性。封装可以隐藏类的内部细节，只对外暴露必要的接口，增强了对程序的保护性。

3. 抽象类和抽象方法

抽象类和抽象方法是面向对象编程（OOP）中的两个重要概念，它们用于定义通用的接口和行为，同时允许具体的子类提供具体的实现。

抽象类

定义

抽象类是一种不能被实例化的类，它提供了一个框架或模板，供其他类继承。抽象类可以包含抽象方法（没有实现的方法）和具体方法（有实现的方法）。

特点

1. 不能实例化：你不能创建一个抽象类的对象。
2. 可以包含抽象方法和具体方法：抽象类可以包含没有实现的抽象方法，以及具有实现的具体方法。
3. 子类必须实现抽象方法：任何继承抽象类的子类都必须实现所有的抽象方法，除非子类也是抽象类。

示例（Java）

abstract class Animal {
    // 抽象方法，没有实现
    abstract void makeSound();

    // 具体方法，有实现
    void sleep() {
        System.out.println("Sleeping...");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Bark");
    }
}

在这个例子中，Animal是一个抽象类，包含一个抽象方法makeSound()和一个具体方法sleep()。Dog类继承Animal类，并实现了makeSound()方法。

抽象方法

定义

抽象方法是没有方法体的方法，仅有方法签名，用于在抽象类中声明。抽象方法要求子类必须提供其实现。

特点

1. 没有方法体：抽象方法只有方法签名，没有方法体。
2. 必须在抽象类中声明：抽象方法只能在抽象类中声明。
3. 子类必须实现：继承抽象类的子类必须实现所有的抽象方法，除非子类也是抽象类。

示例（Python）

抽象类 Animal
abstract class Animal {
    // 抽象方法，没有方法体
    abstract void makeSound();

    // 具体方法，有方法体
    void sleep() {
        System.out.println("Sleeping...");
    }
}

// 具体类 Dog 继承自抽象类 Animal
class Dog extends Animal {
    // 实现抽象方法 makeSound
    @Override
    void makeSound() {
        System.out.println("Bark");
    }
}

public class Main {
    public static void main(String[] args) {
        // 不能实例化抽象类
        // Animal animal = new Animal(); // 编译错误

        // 实例化具体类 Dog
        Dog dog = new Dog();
        dog.makeSound(); // 输出：Bark
        dog.sleep();     // 输出：Sleeping...
    }
}

为什么需要抽象类和抽象方法？

1. 定义通用接口

抽象类和抽象方法允许你定义一个通用接口，而不具体实现细节。这样，多个子类可以实现相同的接口，从而保证代码的一致性和可维护性。

2. 代码复用

通过在抽象类中定义具体方法，子类可以继承和重用这些方法，减少代码重复，提高代码复用性。

3. 强制约束

抽象类强制子类实现特定的方法，这样可以确保子类具有某些行为或功能，从而提高代码的可靠性和可预测性。

4. 灵活性

抽象类允许你在某些情况下提供默认的实现，同时在其他情况下强制子类提供具体的实现，从而提高代码的灵活性和扩展性。

tips：java继承

在创建类的实例时先进入父类进行相关处理，主要有以下原因：

继承关系中，子类是基于父类扩展而来的。在创建子类对象时，需要先确保父类的部分得到正确的初始化和设置，这样才能保证子类对象在完整的继承结构基础上正确构建。父类的属性、状态等可能会影响到子类的行为和表现，所以要先处理父类的部分，这是符合面向对象编程中继承机制的逻辑顺序的。这样能保证整个对象体系按照正确的层次和顺序进行初始化和构建。

java的异常

try catch