JAVA基础 类、对象、方法、实例变量、 Java 源程序与编译型运行区别、面向对象

1.基本概念

1.1 类、对象、方法和实例变量的概念

• 对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
• 类：类是一个模板，它描述一类对象的行为和状态。
• 方法：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。
• 实例变量：每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定。

代码演示：

package demo;

public class Demo01 {
    public static void main(String[] args) {
//        对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
//        类：类是一个模板，它描述一类对象的状态和行为。
//        方法：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。
//        实例变量：每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定。也就是构造函数
        
        TestDemo demo = new TestDemo("小猪佩奇",2);
        
        // 如果类没有toString方法,得到的是 demo.TestDemo@3ac3fd8b  得到目标类的地址,
        // 有toString 打印得到  TestDemo{name='小猪佩奇', age=2}
        System.out.println(demo);
    }
}

class TestDemo{
    private String name;
    private int age;

    public TestDemo(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

//    @Override
//    public String toString() {
//        return "TestDemo{" +
//                "name='" + name + '\'' +
//                ", age=" + age +
//                '}';
//    }
    
}

1.2 Java 源程序与编译型运行区别

1.3  面向对象(封装，继承，多态)

封装：

封装是一种将数据（属性）和对数据的操作（方法）结合在一起，限制外部对对象内部状态的直接访问的机制。封装的主要目的是保护对象的内部状态，确保数据的完整性和安全性。

进一步说，所谓的封装就是把类的属性和方法使用private修饰，不允许其他类的调用者直接访问。要访问的话，可以通过编写相应的构造函数来实现对该类的成员进行赋值操作，或者调用该类的setXxx()方法来实现。

从报错信息可以知道，不能通过 （对象.成员）的方式来调用，因为是private访问修饰符来修饰的.

但是可以通过相应的getXxx和setXxx公共方法去调用。

继承：

继承是指一个类（子类）可以继承另一个类（父类）的属性和方法。

这种机制允许代码重用，并可以形成类的层次结构。

利用继承的方法，可以重用已存在类的方法和属性，而不用重写这些代码。被继承的类称为超类（super class），派生类称为子类（sub class）。

继承主要解决的问题是：共性的抽取，实现代码复用，使得子类可以使用父类的同时，有更多的拓展。

需要注意：类之间只能单继承，但是可以继承多个接口。                                                  

代码演示：

class Animal {
    protected void sound() {
        System.out.println("Animal makes a sound.");
    }
}

class Dog extends Animal { // Dog 类继承 Animal 类
    public void sound() {
        System.out.println("Dog barks.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.sound(); // 输出: Dog barks.
    }
}

多态：

多态是指同一操作作用于不同的对象时，可以有不同的表现形式。

多态主要通过方法重载和方法重写实现。

代码演示：

class Animal {
    public void sound() {
        System.out.println("Animal makes a sound.");
    }
}

class Cat extends Animal {
    @Override // 重写父类的方法
    public void sound() {
        System.out.println("Cat meows.");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Cat(); // 父类引用指向子类对象
        myAnimal.sound(); // 输出: Cat meows.
    }
}