Java面向对象（基础总结）

最新推荐文章于 2024-11-08 19:42:07 发布

清风挽歌

最新推荐文章于 2024-11-08 19:42:07 发布

阅读量2.3w

点赞数 49

分类专栏： Java学习笔记文章标签： java 编程语言

本文链接：https://blog.csdn.net/zxy144/article/details/108248542

版权

Java学习笔记专栏收录该内容

34 篇文章 10 订阅

订阅专栏

Java面向对象（基础总结）

面向对象是一种编程思想。

面向对象的三大基本特征：
- 封装
- 继承
- 多态
面向对象的编程思想就是把事物看作一个整体，从事物的特征（属性）和行为（方法）两个方面进行描述。
面向对象的过程就是找对象、建立对象、使用对象、维护对象的关系的过程

面向过程和面向对象

	面向过程	面向对象
设计思路	自顶向下、层次化、分解	自底向上、对象化、综合
程序单元	函数模块	对象
设计方法	程序=算法+数据结构	程序=对象=数据+方法
优点	相互独立，代码共享，性能相对较高	接近人的思维方式，使用灵活，易维护、易复用、易扩展
缺点	修改、维护困难	性能相对较低

面向对象是基于面向过程的
面向对象能让复杂的问题简单化，程序员不需要了解具体的实现过程，只需要指挥对象去实现功能（从执行者变成指挥者）。

举例：

洗衣服：
- 使用面向过程思考：放入衣服 -> 打开洗衣机 -> 洗衣服 -> 关闭洗衣机
- 使用面向对象思考：洗衣服我们操作了洗衣机这个对象，所以只要给洗衣机这个对象增加这些功能，就可以实现洗衣服操作。放入衣服 -> 洗衣机：打开、洗衣服、关闭
面向过程：强调步骤；面向对象：强调对象。

面向对象的三大核心特性：

可重用性：代码重复使用，减少代码量，提高开发效率。面向对象的三大基本特征（继承、封装和多态）都围绕这个核心。
可扩展性：指新的功能可以很容易地加入到系统中来，便于软件的修改。
客观理性：能够将功能与数据结合，方便管理。

抽象

所谓的抽象，就是把同一类事物中共有的特征(属性)和行为(功能、方法)进行抽取，归纳，总结。

抽象的过程其实就是面向对象编程的核心思想

类

类：用来描述一类具有相同特征（属性）和相同行为（方法）的对象。（可以比喻为模板）

Java中用class关键字来描述类
- 成员属性（变量）：对应的就是事物的属性
- 成员方法：对象事物的行为

类的定义：

public class 类名{
    //成员变量
    //成员方法
}

定义类：就是定义类的成员，包括成员变量和成员方法
类的成员：
- 成员变量：和之前定义的变量几乎时一样的，只不过位置发生了改变，成员变量位于类中，任何方法之外。
- 成员方法：和之前定义的方法几乎是一样的，只不过把static关键字去掉

类和对象的关系：

类是对象的抽象
对象是类的实例化

对象

对象（Object）是系统中用来描述客观事物的一个实体，它是构成系统的一个基本单位。

它们是有形的，如一个人、一件物品；也可以是无形的，如一个计划、一次交易。（万事万物，皆对象）

创建对象
```
类名 对象名 = new 类名();
```
使用对象：

调用成员变量：

对象名.成员变量；

调用成员方法：

对象名.方法名(参数列表);
成员变量（属性）都有默认值，所以在声明成员变量时，可以不用初始化（默认值和数据类型有关：）

数据类型默认值
byte 0
short 0
int 0
long 0
float 0.0
double 0.0
boolean false
char 空字符
引用类型 null

数据类型	默认值
byte	0
short	0
int	0
long	0
float	0.0
double	0.0
boolean	false
char	空字符
引用类型	null

全局变量（成员变量）

定义在方法的外部，类的内部。使用范围是整个类
不需要初始值
存储在堆内存中（对象存在时才在存在）

局部变量

（方法中的变量）

定义在方法的内部或者某一个语句块的内部，适用范围仅限于方法内或者语句块内
必须有初始值
存储在栈内存中

成员方法

语法：

访问修饰符 返回值类型 方法名称(参数列表){
    方法体
}

访问修饰符：public
返回值类型由返回值决定

成员变量可以直接在成员方法中使用，但是main方法中如果调用成员变量和方法必须通过对象.属性名\方法名(参数列表)的形式来调用
成员方法之间的调用，直接写方法名(参数列表)即可

构造方法

对象一建立就会调用构造方法，可以创建对象，给成员变量（属性）初始化。

方法名和类名相同
没有返回值和void，没有return
不能被static等关键字修饰
可以方法重载（定义多个参数列表不同的构造方法）
当一个类中没有写构造方法时，系统会默认给该类一个默认的无参构造方法。当自己定义构造方法后默认的构造方法就不存在了。（自己定义有参的构造方法后，如果还想使用无参的构造方法，就要自己再添加一个无参的构造方法）

public class Animal {
    String name;
    int age;
    //构造方法
    public Animal(){
        System.out.println("------无参的构造方法------");
        name = "动物";
        age = 0;

    }
    public Animal(String name,int age){
        System.out.println("------有参的构造方法------");
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {
        //创建对象
        Animal a1 = new Animal();
        System.out.println(a1.name+","+a1.age);

        Animal a2 = new Animal("兔子",2);
        System.out.println(a2.name+","+a2.age);
    }
}

this关键字

this代表它所在方法所属对象的引用。哪个对象调用的this所在的方法，this就代表哪个对象。

在没有static关键字修饰的方法中使用

this关键的字用来区分成员变量和局部变量同名的情况：

public class Student{
    //成员变量
    String name;
    int age;
    int classNum;

    public Student(String name,int age,int classNum){    
        //s1调用了构造方法，所以这里的this代表s1对象
        this.name = name; //成员变量name=局部变量name
        this.age = age;
        this.classNum = classNum;
    }
    
    public static void main(String[] args){
        Student s1 = new Student("张三",18,1);
        System.out.println(s1.name);//打印 张三
    }
}

this关键字在构造方法中的第一行以 this(参数列表) 的形式出现时，就表示当前构造方法调用了该类中其他的构造方法（于参数列表相匹配的构造方法）：

public class Test1 {
    
    public Test1(){
        this("张三",18);
    }
    public Test1(String name,int age){
        System.out.println("姓名："+name+"，年龄："+age);
    }

    public static void main(String[] args) {
        Test1 test1 = new Test1();
    }
}

封装

封装是将代码及其处理的数据绑定在一起的一种编程机制，该机制保证了程序和数据都不受外部干扰且不被误用。

封装的目的在于保护信息，保证数据的安全性
封装包括两个方面：属性的封装和方法的封装
Java 提供了私有和公有的访问模式，类的公有接口代表外部的用户应该知道或可以知道的每件东西，私有的方法数据只能通过该类的成员代码来访问，封装不是绝对的封装，如果想要访问封装起来的数据，可以通过指定的入口即可
属性和方法的封装两者时相辅相成、密不可分的

继承

程序中的继承性是指子类拥有父类的全部特征和行为，这是类之间的一种关系。

继承的特点：
- 继承要有一定的层次结构，而且还要具备一定的可传递性
- 子类继承了父类的所有属性和方法，但是不包括私有属性（private）和构造方法
- 子类继承父类的属性和方法同时也可以有自己的属性和方法。
- Java 只支持单继承。也就是说一个子类只能有一个父类，父类可以有多个子类
继承可以减少重复代码、提高了复用性和维护性
继承让类与类之间产生了关系，类的耦合性增强了，父类发生变化子类也会跟着改变

      //子类继承父类        （继承前面的Animal）
      public class Dog extends Animal{
          public Dog(){
              super();
              System.out.println("---dog---无参的构造方法------");
          }
          public Dog(String name,int age){
              super(name, age);
          }
      	//测试
          public static void main(String[] args) {
              Dog dog = new Dog();
              Dog d2 =new Dog("狗",10);
              System.out.println(d2.name+",age:"+d2.age);
          }
      }

运行结果：

------无参的构造方法------
—dog—无参的构造方法------
------有参的构造方法------
狗,age:10

继承中的构造方法

创建有继承关系的子类对象时，会先执行父类中默认的构造方法，然后执行子类中相关的构造方法
如果父类中不存在默认的构造方法，那么此时的解决问题，第一种就是手动添加一个默认的构造方法。

super关键字

表示当前类的父类的引用
只能出现在有继承关系的子类中
super两种用法：
- super.属性名、super.方法名(参数列表)
  - 表示父类的属性和方法，和子类中的属性或方法重名时使用
- super(参数列表)
  - 出现在子类构造方法的第一句代码时
  - 就是通过参数列表匹配父类的构造方法来创建父类对象

多态

多态就是同一函数在不同类中有不同的实现；

面向对象的多态性，即“一个接口，多个方法”。
多态性体现在父类中定义的属性和方法被子类继承后，可以具有不同的属性或表现方式。
多态性允许一个接口被多个同类使用，弥补了单继承的不足。

实例：

//父类
public class Animal {
    public void talk(){
        System.out.println("讲话");
    }
}
*******************************************
//子类
public class Cat extends Animal{
    public void talk(){
        System.out.println("喵喵");
    }
}
*******************************************
//子类
public class Dog extends Animal{
    public void talk(){
        System.out.println("汪汪");
    }
}
*******************************************
//测试类
public class Test {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.talk();
        //以父类的名义实例化
        Animal dog = new Dog();
        //以子类自己的方法实现
        dog.talk();
        Animal cat = new Cat();
        cat.talk();
    }
}