面向对象的一些知识

标签：对象子类知识面向对象一些抽象类父类方法属性

文章目录

类与对象
private修饰符 - 私有化
this关键字 - 本对象
封装
构造方法
static修饰符 - 静态的
继承
- 优缺点
- 子类能否继承父类所有属性和方法
super关键字
重写/复写
访问修饰符
Object
final
抽象类
抽象方法
接口
多态
内部类

类与对象

类里有什么内容？

一个类中可以有成员方法、静态方法、成员属性、抽象方法、静态属性

类和对象的关系

类是抽象的表示，类中只能有属性和方法

对象是类的具象化，面对对象就是利用类去创造该类的对象，然后用该对象去操作类的属性和方法

对象和引用的关系

Person p = new Person();
//没对象的兄弟有福了，可以在这里new一个，想要什么类型都可以自己new，哈哈哈

对象->new Person()，new出的是对象，对象在堆中开辟空间

引用->p，引用中存储的是对象的地址

对象在哪里开辟空间

方法里的对象如果被返回了，就会在堆里开辟空间，如果没有返回，仅在方法内部使用，则会在栈里开辟

private修饰符 - 私有化

如果修饰属性，则该属性不能在该类以外使用

如果修饰方法，则该方法不能在该类以外使用

this关键字 - 本对象

this.属性：在成员方法中调用本对象的属性

this.方法：在成员方法中调用本对象的方法

this([值])：在构造方法的第一句调用其他的构造方法

注：在静态方法中不能使用this，因为静态方法属于类的方法，直接使用类名调用

封装

概念：将数据和操作数据的方法（即行为）打包在一起，形成一个相对独立的、可复用的软件模块，同时对外部隐藏对象的内部细节和具体实现的过程。

步骤：

1.私有化属性

2.添加get、set方法

问：为什么要使用封装？

属性直接调用会有数据安全的问题，通过添加get、set方法去获取和设置

构造方法

与类名相同且没有返回项的方法叫做构造方法

作用：创建对象、初始化数据（静态属性、成员属性）

static修饰符 - 静态的

1.修饰属性：该属性变为类属性，直接由类名调用

2.修饰方法：该方法变为类方法，直接由类名调用

3.修饰代码块，该代码块变为静态代码块，可以初始化静态属性

继承

子类继承父类所的方法和属性

注：创建子类对象不会创建父类对象，但是会调用父类构造方法，开辟空间存放父类成员属性

优缺点

优点：减少了代码冗余

缺点：增加了程序功能实现的复杂度，增加了类于类之间的关联度

子类能否继承父类所有属性和方法

虽然Java官方的说法是子类不能继承父类的私有化方法和属性，但你可以在父类再写一个公有方法，在公有方法调用父类的私有化属性和方法，然后在子类调用该公有方法

super关键字

super.属性：在子类中，调用父类非私有化的成员属性

super.方法：在子类中，调用父类非私有化的成员方法

super([值])：在子类的构造方法的第一句调用父类非私有化的构造方法

重写/复写

将父类方法在子类重新编写一遍

要求：

1.在子类中重写

2.返回值类型、方法名、参数列表都必须和父类一致

3.访问修饰符不能比父类更严格

访问修饰符

private、默认的、protected、public，每个修饰符都有不同权限

private：只允许在本类

默认：在本类和本包

protected：在本类、本包、其他包的子类

public：本类、本包、其他包的子类、其他包

修饰范围：

类：默认的、public

方法、属性：private、默认的、protected、public

Object

所有类的超类，一个方法没有明确继承的父类，那么它默认继承Object类

常用方法：

1.equals：判断两个对象的内存地址是否相同,子类重写该方法即可

2.getClass：获取字节码文件对象,子类重写该方法即可

3.hashCode：获取对象的hash码，在反射中使用

4.toString：获取对象的字符串表示，在获取hash值时使用

final

应用场景：

1.修饰属性：该属性变为常量，存放在常量池中

2.修饰方法：该方法不能被子类重写

3.修饰类：该类不能被继承

抽象类

抽象类是一种不能实例化的类，其目的是为了被继承而设计的。它可以包含抽象方法和具体方法。

特点：

1.抽象类不能直接实例化，只能被子类继承。

2.抽象类可以包含抽象方法和具体方法。

3.子类继承抽象类后，必须实现抽象类中的所有抽象方法，除非子类自身也是抽象类。

4.可以有构造方法，但是不能用来实例化抽象类。

abstract class Animal {
    String name;
	// 抽象方法
	abstract void makeSound();

	// 具体方法
	void eat() {
  	  System.out.println(name + " is eating.");
	}
}

class Dog extends Animal {
    // 实现抽象方法
    void makeSound() {
        System.out.println("Woof!");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        myDog.name = "Buddy";
        myDog.makeSound();
        myDog.eat();
    }
}

抽象方法

抽象方法是一种声明但不实现的方法，它必须在抽象类中声明（不能在普通类中声明），并且子类必须实现（override）这些方法

特点：

1.没有方法体，以分号结束。

2.子类必须实现所有抽象方法，否则子类也必须声明为抽象类。

abstract class Shape {
    abstract void draw(); // 抽象方法
}

class Circle extends Shape {
    void draw() {
        System.out.println("Drawing Circle");
    }
}

public class Main {
    public static void main(String[] args) {
        Shape shape = new Circle(); // 合法，子类实现了抽象方法
        shape.draw();
    }
}

接口

特殊的抽象类

声明方法：接口只能声明方法，而不能实现方法的代码体。所有在接口中声明的方法都是抽象的，不需要加上 abstract 关键字。
实现接口：一个类可以通过实现（implement）接口来表明它遵循了接口所定义的协议。一个类可以实现多个接口，这种多继承的特性使得接口在某些情况下比抽象类更灵活。
强制约束：实现接口的类必须实现接口中声明的所有方法，否则会导致编译错误。
无状态：接口本身不包含任何状态信息（实例变量），只包含行为的声明。
应用：接口常用于定义模块之间的协议，使得不同模块可以通过接口进行交互而不依赖于具体实现，从而提高了代码的可维护性和扩展性。

多态

指的是同一个方法调用可以在不同的对象上有不同的行为。多态性使得程序可以根据对象所属的类来调用相应的方法，从而实现方法的重用和灵活性的增强。

方法重写：多态是通过方法重写（Override）来实现的，子类可以重写父类的方法，即在继承关系中，子类可以对父类中的方法进行重新定义。
编译时类型和运行时类型：在运行时，对象的实际类型决定了调用哪个方法，而在编译时，方法调用会根据声明变量的类型来确定。
实现方式：多态可以通过继承实现，也可以通过接口实现。在继承中，子类重写父类的方法，从而表现出不同的行为；在接口中，不同的实现类可以实现同一个接口的方法，表现出不同的行为。
提高灵活性：多态性使得程序可以根据对象的类型动态调用适当的方法，这样在不同情况下可以使用相同的方法名执行不同的操作，从而提高了代码的可复用性和可扩展性。

内部类

在一个类的内部定义另一个类

成员内部类（Member Inner Class）：定义在另一个类的内部，作为该类的成员。它可以访问外部类的所有成员（包括私有成员），并且可以使用 this 关键字引用自身。
静态内部类（Static Nested Class）：定义在另一个类的内部，但使用 static 修饰。静态内部类不持有对外部类对象的引用，因此它只能直接访问外部类的静态成员，而不能访问非静态的外部类成员。
局部内部类（Local Inner Class）：定义在方法内部的类，作用域限定在方法内部。局部内部类可以访问方法的参数和局部变量，但是这些变量必须声明为 final 或是实际上是 final 的（Java 8及以后版本放宽了对变量的限制）。
匿名内部类（Anonymous Inner Class）：是一种没有类名的局部内部类，通常用于创建实现某个接口或是继承某个类的对象，且只使用一次的情况。匿名内部类必须实现接口或继承抽象类，并在定义的同时进行实例化。

若有错误，欢迎指正！

标签：对象,子类,知识,面向对象,一些,抽象类,父类,方法,属性
From： https://blog.csdn.net/nzksk/article/details/140574493