javase 之面向对象

1.1 面向对象思想

只需要两个对象：米饭和会做饭的人，让会做饭的人使用他做饭的方法将米饭的属性从生变成熟就可以了。

面向对象思想从概念上讲分为以下三种：OOA、OOD、OOP 
OOA：面向对象分析（Object Oriented Analysis） 
OOD：面向对象设计（Object Oriented Design） 
OOP：面向对象程序（Object Oriented Programming
 

1.2 三大特性

封装性：所有的内容对外部不可见 
继承性：将其他的功能继承下来继续发展 
多态性：方法的重载本身就是一个多态性的体现
 

1.3 定义格式

属性定义格式： 
    数据类型 属性名; 
属性定义并赋值的格式： 
    数据类型 属性名 = 初始化值; 
    
方法定义格式： 
权限修饰符 返回值类型 方法名(形式参数列表){ 
    //方法体 
    return 返回值； 
}

1.4 怎么搞对象

一个类要想真正的进行操作，则必须依靠对象，对象的定义格式如下: 

类名称 对象名称 = new 类名称() ; 

如果要想访问类中的属性或方法（方法的定义），则可以依靠以下的语法形式： 

访问类中的属性： 对象.属性 ; 

调用类中的方法： 对象.方法(实际参数列表) ; 

eg:

import java.util.Scanner

Scanner sc=new Scanner(System.in);

int a=sc.nextInt();

string b=sc.nextLine();

.........

1.5 构造方法

什么是构造方法：平时new 的一个对象就是使用的构造方法，如：Person p = new Person(); Person()就是用了构造方法。

注意：

1、如果自行编写了任意一个构造器, 则编译器不会再自动生成无参的构造方法！所以以后写了有参构造一定要补无参构造！

2、构造方法必须跟类同名，而普通方法不行。

3.如果一个类中没有明确的编写构造方法, 则编译器会自动生成一个无参的构造方法, 构造方法中没有任何的代码！

1.6 方法重载

方法的重载指的是方法能够有不同的参数和返回值。调用同名方法的时候能根据传入参数的类型来使用对应的方法。

1.7 什么是构造方法重写

构造方法重写是指在子类中定义某方法与其父类有相同的名称和参数，则该方法被重写。子类函数的访问修饰权限不能小于父类的；若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法 。

声明为static和private的方法不能被重写，但是能被再次声明。

final方法也不能被重写，详见final的描述。

1.8 那重写和重载的区别在哪里呢

构造方法重写和重载的区别在于：

• 重载是指在同一个类中，方法名相同，参数类型、参数个数不同，或者参数顺序不一样。而重写是存在于子类中，方法名相同、返回类型相同、访问权限只能扩大不能缩小、参数必须相同 。
• 重载不用继承父类，而重写必须继承父类。
• 重载的方法名相同，参数列表不同；而重写的方法名相同，参数数目相同，参数类型兼容。

eg：

Animal父类

public class Animal {
    private String name;
    private int age;
    
    // 带参数的构造方法
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // 不带参数的构造方法
    public Animal() {
        this.name = "Unknown";
        this.age = 0;
    }
    
    public void introduce() {
        System.out.println("My name is " + name + ", and my age is " + age + " years old.");
    }
}
 

Dog子类

public class Dog extends Animal {
    private String breed;
    
    // 重写父类的无参构造方法
    public Dog() {
        super(); // 调用父类的无参构造方法来初始化父类的成员变量
        this.breed = "Poodle"; // 初始化自己的成员变量breed为"Poodle"
    }
    
    @Override
    public void introduce() {
        super.introduce(); // 调用父类的introduce方法来输出自己的信息，然后再加上自己的信息即可
        System.out.println("I am a Poodle, my age is " + age + " years old.");
    }
}
 

2 面向对象进阶

2.1 封装：指将数据和方法包装在一起，对外部隐藏实现细节，只提供公共的接口

封装的意义在于保护或者防止代码（数据）被我们无意中破坏；

保护成员属性，不让类以外的程序直接访问和修改。

封装原则：隐藏对象的属性和细节，仅对外公开访问方法，并且控制访问级别。

封装四种修饰符的不同作用域：private（类内部），缺省（同包下），protected（不同包的子类），public（公共的）

怎么实现封装呢？

1. 使用访问修饰符来限制类、方法和变量的访问权限。Java中有四种访问修饰符：public、protected、default（没有修饰符）和private。一般情况下，应该将类、方法和变量设置为private或default，将需要被其他类访问的属性和方法设置为public。

2. 提供公共的getter和setter方法来访问和修改私有属性。这些方法被称为“getter”和“setter”，它们的作用是提供一种安全的方式来访问和修改私有属性，而不是直接访问私有属性。

给出demo

public class Student {
    private String name; // 私有属性
    private int age; // 私有属性
    
    // getter和setter方法
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        if (age >= 0 && age <= 150) { // 对属性值进行合法性检查
            this.age = age;
        } else {
            throw new IllegalArgumentException("Invalid age");
        }
    }
}
 

所谓setter和getter方法就是自定义函数，get方法直接return 封装值

set方法需要传参数，就是我们要修改的哪一个值，比如 

this.value=value;

2.2 静态static

static修饰的属性/方法在类加载时就会加载，会加载到方法区中；可以使用类名.属性/方法直接调用static修饰的属性/方法。
注意：static修饰的属性/方法不能被对象调用！只能类名调用！

3.1 继承

格式：

修饰符 class 子类 extends 父类{
}

 

子类能继承并使用父类所有非private修饰的属性和方法。

那子类可以继承并使用父类的private修饰的属性和方法吗？
可以！但是这样不安全，会导致程序不稳定和数据不安全性，应尽量避免

1.在父类中提供public的getter和setter方法，供子类访问和修改private属性。

代码demo

eg.1:

public class Parent {
    private String name;
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
}

public class Child extends Parent {
    // 子类可以直接使用父类的public getter和setter方法来访问和修改private属性
}

2.在父类中将private属性或方法声明为protected或package-private（默认），使其对子类可

eg.2:

public class Parent {
    protected String name; // 或者将属性声明为package-private
    
    protected void printName() { // 或者将方法声明为package-private
        System.out.println(name);
    }
}

public class Child extends Parent {
    // 子类可以直接访问和调用父类的protected或package-private属性和方法
}
 

另外

在Java中只能单继承，一个或多个子类只能继承一个父类。

继承能够多级继承，即孙子类继承子类，子类继承父类。

另外，Java里所有没有继承的类都会默认继承Java的Object类，而继承又能多级继承，也就是说，Java里面所有的类都是Object的子类！

3.2 supper（）

如果父类写了有参的构造方法，那么子类必须写一个构造方法，构造方法第一句加上super（参数），否则会报错！

因为编译器默认的无参构造方法被覆盖了！导致子类默认的super（）找不到父类的无参构造！所以必须写出来！

如果父类补上了无参构造就不会报错，这就是为什么一定要注意补无参。


3.2.1 final

final顾名思议，是最终的，不可改变的；

可以用来修饰类、属性和方法，final修饰的变量会变成常量。

final修饰的类不可被继承；
final修饰的属性只能赋值一次，不可被再次赋值；
如果final修饰的是类的成员变量，则必须初始化（直接赋值或构造方法赋值）
如果final修饰的是局部变量，可以先声明再赋值，但依然只能赋值一次
final修饰的方法不能被子类重写；
static final修饰的变量视为常量！常量通常用大写字母来表示！
 

3.3 抽象->不知道怎么做就是抽象

3.3.1 抽象类->有抽象方法（作为父类被继承）

什么是抽象类：如果一个类中需要有暂时不确定怎么做的方法，那么就可以定义一个抽象方法，有抽象方法的类就叫抽象类。

• 使用abstract修饰的类就是抽象类
• 抽象方法：只声明但未实现的方法就是抽象方法，没有方法体，必须使用abstract来声明。
• 抽象类中可以没有抽象方法，但有抽象方法的类一定是抽象类！

注意：抽象类中有构造方法，只是抽象类不能通过构造方法来创建对象！

抽象类就是专门用来继承的！所以抽象类只能被public或protected修饰！同理抽象类也不能被final修饰！

如果一个类继承了抽象类，那么必须重写抽象类中所有的抽象方法！（当然没有抽象方法就不用重写了）

3.4 接口

接口其实就是特殊的抽象类。

接口中所有的方法都是抽象方法，默认使用public abstract修饰。

接口中可以也只能定义全局常量，默认使用public static final 修饰。

接口可以实现，跟继承一样，但不同的是接口可以多实现。

实现一个接口必须实现接口中定义的（默认为抽象）方法！
 

代码demo

// 定义一个名为Animal的接口，声明了一个叫声方法
interface Animal {
    void makeSound();
}

// 定义一个名为Dog的类，实现了Animal接口
class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("汪汪汪");
    }
}

// 定义一个名为Cat的类，实现了Animal接口
class Cat implements Animal {
    @Override
    public void makeSound() {
        System.out.println("喵喵喵");
    }
}

// 在主类中创建Dog和Cat对象，并调用它们的makeSound方法
public class Main {
    public static void main(String[] args) {
        Animal dog = new Dog();
        dog.makeSound(); // 输出：汪汪汪

        Animal cat = new Cat();
        cat.makeSound(); // 输出：喵喵喵
    }
}

3.5 多态

Java的多态指的是同一个方法名、参数列表和返回值类型在父类中定义，子类可以对其进行重写。当使用父类引用指向子类对象，调用该方法时，实际执行的是子类中重写后的方法。这种特性使得程序具有更好的扩展性和灵活性。

demo:

假设有一个父类Animal和一个子类Dog：

public class Animal {
    public void eat() {
        System.out.println("Animal is eating");
    }
}

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating");
    }
}

这里定义了一个eat()方法，在Animal类中进行声明。Dog类继承了Animal类，并重写了eat()方法。此时我们可以用父类Animal的引用来指向子类Dog的对象，并调用eat()方法：

Animal animal = new Dog(); // 父类引用指向子类对象
animal.eat(); // 输出：Dog is eating

可以看到，虽然使用的是父类的引用来调用方法，但实际上执行的是子类Dog中重写的eat()方法。这就是Java中的多态特性。

3.6 object

所有类的父类！

主要的就是 equals（）方法和toString（）方法

3.6.1 equals()

equals（）是一个方法，作用是判断两个对象是否相等，返回true或false。 Object里面的equals（）就是用的 ==比较，比较的是对象的引用，如果是基本数据类型，那么就是比较常量池里的值，而如果是对象，则比较的是对象指向的堆内存地址。如果想要比较两个对象，让他们的属性相同就能相等，那么可以重写equals（）方法
 

3.6.2 tostring()

toString（）方法是用来显示一个对象的，

我们平常的System.out.println(a);就是用的a这个对象的toSting（）方法来显示

重写toString（）就能更好的显示一个对象！