Java学习——面向对象基础

于 2023-02-25 20:24:25 发布
阅读量261 收藏
点赞数
分类专栏： 笔记 文章标签： java 学习 jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45944185/article/details/129219185
版权

1. 面向对象的基本操作

  1. 类型设计
  2. 类对象实例化操作
  3. 类对象/类名调用方法操作，功能执行和数据操作【重点】
/**
 * 自定义的数组工具类
 *
 * @author Anonymous 2023/2/24 9:45
 */
public class MyArrayUtils {
    /**
     * 自定义方法，实现 int 类型数组数据展示功能
     *
     * @param arr int 类型数组
     */
    public static void printIntArray(int[] arr) {
        /*
        增强 for 循环
            for (int i = 0; i < arr.length; i++) {}
            for (int i : arr) {}

            for (当前数组/集合存储的数据类型 在循环中使用的临时变量 : 数组/集合)
                增强 for 循环自动遍历整个数组/集合，临时变量存储遍历数组对应的数据
         */
        for (int i : arr) {
            System.out.println(i);
        }
    }
}


public class Student<val> {
    private Integer id;
    private String name;
    private Integer age;
    private Boolean gender;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public Boolean getGender() {
        return gender;
    }

    public void setGender(Boolean gender) {
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", gender=" + gender +
                '}';
    }
}


public class Demo1 {
    public static void main(String[] args) {
        // 实例化 Student 对象 【实体类 数据的载体】
        Student student = new Student();

        // 1. 利用方法对于 Student 对象数据存储进行修改和获取
        student.setId(1);
        student.setName("张三");
        student.setAge(66);
        student.setGender(false);

        System.out.println(student);

        System.out.println();
        System.out.println(student.getId());
        System.out.println(student.getName());
        System.out.println(student.getAge());
        System.out.println(student.getGender());
        System.out.println();

        int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};

        // 通过类调用功能方法，实现目标功能
        MyArrayUtils.printIntArray(arr);
    }
}

2. 面向对象两大任务

1.数据的载体(人和马云)
2. 方法的载体(工具箱和扳手)

3. 面向对象三大特征

3.1 封装

JavaBean 规范实体类要求

  1. 要求所有成员变量全部 private 私有化修饰

  2. 必须提供所有成员变量对应的 getter and setter 方法

  3. 必须提供无参数构造方法

案例：

public class Student {
    // 私有化成员变量 Field
    private Integer id;
    private String name;
    private Integer age;
    // boolean 类型成员变量对应的 getter 方法是 is开头 ==> isGender
    // Boolean 包装类型还是 get 和 set 开头
    private boolean gender; //private Boolean gender;
   	
    
    // 构造方法 Constructor
    public Student() {}
    
    public Student(Integer id, String name, Integer age) {
        // this 关键字目前的作用是区分成员变量和参数变量
        // this 表示 new + 当前构造方法实例化的对象本身
        this.id = id;
        this.name = name;
        this.age = age;
    }
    
    // getter and setter
    public Integer getId() {
        return id;
    }
    
    public void setId(Integer id) {
        this.id = id;
    }
    ...
}
3.2 继承
3.2.1 基本格式和特征
class A extends B {

}
A 类是 B 类的一个子类
B 类是 A 类的唯一父类
    
/*
特征：
	1. 父类中非私有化成员(成员变量和成员方法)都可以继承给子类使用
	2. 父类中私有化成员子类无法获取
	3. 实例化子类对象会默认调用父类的无参数构造方法。
		父类构造方法是用于继承给子类数据内容对应内存空间初始化操作使用的方法。
		JVM 设计规则【先有父，再有子】
*/
3.2.2 重写方法

子类继承父类方法，父类方法无法满足子类的特征需求，可以进行重写操作。
重写操作要求:
1. 要求方法声明完全一致，包括返回值类型，方法名和形式参数列表
2. 权限修饰符子类权限必须大于等于父类
父类 public 子类允许 public
父类 protected 子类允许 public protected
3. 重写方法必须有 @Override 注解

3.2.3 重载方法

同一个类，或者同一个接口内
重载方法要求:
1. 方法名必须一致
2. 方法形式参数列表数据类型必须不同
3. 返回值类型无限制
4. 权限修饰符无限制

/*
方法重载 Reload
 */
public static void test(int num) {
    System.out.println(num);
}
public static void test(int num1, int num2) {
    System.out.println(num1 + num2);
}
private static void test(float num) {
    System.out.println(num);
}
3.3 多态

4. 权限修饰符的作用范围

publicprotectedprivate
同一包√√×
同一类√√√
子孙类√√×
不同包√××

5. 关键字

5.1 abstract

语法特征：

  1. abstract 修饰的方法有且只有方法声明，没有方法体
  2. abstract 修饰方法有且只能定义在 abstract 修饰的类内或者 interface 接口内
  3. 一个非 abstract 修饰类继承 abstract 类或者 遵从 interface 接口，要求实现在 abstract 类中或 interface 接口中有可能存在的 abstract 修饰方法。
  4. 阿里巴巴开发规约要求(AJCG) abstract 修饰的类推荐使用 Abstract 或者 Base 类名开头

代码示例：

/*
abstract 演示
 */
abstract class BaseTest {
    /**
     * abstract 修饰的成员方法，没有方法体
     */
    public abstract void test();
}

class A extends BaseTest {

    @Override
    public void test() {
        System.out.println("子类继承 abstract 类实现的 abstract 方法");
    }
}

/**
 * @author Anonymous 2023/2/24 10:24
 */
public class Demo3 {
    public static void main(String[] args) {
        /*
         匿名对象，可以用于调用不会重复使用的方法，或者作为其他方法的参数
         提高代码的执行效率和内存的使用效率
        */
        new A().test();

        /*
        正常操作
         */
        A a = new A();
        a.test();
    }
}
5.2 final
5.2.1 final修饰成员变量

final 修饰的成员变量要求必须进行初始化操作
【解决方案】

  1. 直接初始化赋值
  2. 有参数构造方法，实例化对象过程中初始化 final 修饰成员变量
  3. final 修饰的成员变量一旦被赋值无法二次修改
class A {
    /*
    Variable 'msg' might not have been initialized
    msg 变量可能尚未初始化
    【解决方案】
        1. 直接初始化赋值
        2. 【有参】数构造方法，实例化对象过程中初始化 final 修饰成员变量
     */
    public final String msg = "直接赋值 final 修饰成员变量";
}

class B {
    public final String info;

    /**
     * 当前类有且只有有参数构造方法，并且当前有参数构造方法参数内容
     * 是给予当前类内 final 修饰的成员变量 info 进行初始化赋值操作
     * 可以满足在用户使用 info 之前可以已经赋值准备好对应的数据内容。
     *
     * @param info 赋值 final 修饰成员变量对应的参数
     */
    public B(String info) {
        this.info = info;
    }
}

/**
 * @author Anonymous 2023/2/24 10:32
 */
public class Demo1 {
    public static void main(String[] args) {

        A a = new A();
        // final 修饰的成员变量无法进行二次赋值操作。
        // a.msg = "测试";
        System.out.println(a.msg);

        B b = new B("通过有参构造方法赋值 final 修饰成员变量");
        System.out.println(b.info);
    }
}
5.2.1 final修饰成员方法

final 修饰成员方法不允许被子类重写
一般用于框架，业务核心代码内容修饰，不允许修改/重写代码内容

class C {
    public final void test() {
        System.out.println("C 类 test 成员方法");
    }
}

class D extends C {
    /*
    'test()' cannot override 'test()' in 'com.qfedu.b_final.C'; overridden method is final

    final 修饰的成员方法，子类不允许重写。
        一般用于框架，业务核心代码内容修饰，不允许修改/重写代码内容

    @Override
    public void test() {
        System.out.println("D 类继承 C 类重写 test 方法");
    }
    */
}

/**
 * @author Anonymous 2023/2/24 10:44
 */
public class Demo2 {
    public static void main(String[] args) {
        new D().test();
    }
}
5.2.1 final修饰类

final 修饰类没有子类
在开发中基本类型不允许继承重新定义/制定规则。

final class  E {

}

/*
Cannot inherit from final 'com.qfedu.b_final.E'
不能继承一个 final 修饰类
final 修饰类没有子类
   在开发中基本类型不允许继承重新定义/制定规则。
   例如：
        Java 中是 String 类，基本数据类型的包装类 Integer Float Double

 */
//class F extends E {
//
//}

/**
 * @author Anonymous 2023/2/24 10:50
 */
public class Demo3 {
}
5.2.1 final修饰局部变量

final 修饰的局部变量首次赋值允许，后期不允许二次赋值

/**
 * @author Anonymous 2023/2/24 10:54
 */
public class Demo4 {
    public static void main(String[] args) {
        final int num ;
        /*
        final 修饰的局部变量，【首次】赋值没有任何的问题
            1. 定义时候初始化
            2. 后期代码赋值
         */
        num = 10;
        System.out.println(num);

        /*
        Cannot assign a value to final variable 'num'
        不能重新赋值一个 final 修饰的局部变量(local variable) num
         */
        num = 20;
    }
}
5.3 static
5.3.1 类加载

游戏加载:
在游戏开始之前，需要加载游戏的相关资源(地图，角色，角色皮肤，角色特效，网络情况…)。在游戏开始之前完成的工作。

类加载同理:
JVM 会根据当前程序运行所需，加载所有的类文件(.class 文件)，程序准备阶段，并且在准备阶段过程中，会执行加载【static】修饰相关内容。

核心:
三个重点：静态成员变量，静态成员方法，静态代码块
一个原则: 类加载过程中 static 修饰内容完成准备工作

5.3.2 static 修饰静态变量

语法特征:
1. static 修饰的静态成员变量在内存的【数据区】
2. static 修饰的静态成员变量在整个代码的运行周期中有且只有一个。
3. static 修饰的静态成员变量在类文件加载阶段，需要准备就绪，已具备数据提供能力和数据存储能力。
4. static 修饰的静态成员变量别名【类变量】，语法建议直接通过类名操作
例如:
Integer.MAX_VALUE ==> public static final int MAX_VALUE = 0x7FFFFFFF;
5. 【使用建议】
静态成员变量最好不要和类对象有相关性。
静态成员变量生命周期从类加载开始到程序结果
类对象是从实例化对象开始，到 JVM GC 回收结束
可以实例化对象相当于程序开始运行，晚于静态成员变量加载
GC 收回是在程序退出之前，完成内存收回工作之后，静态成员变量销毁。

package com.qfedu.c_static;

class A {
    /*
    static 修饰静态成员变量
     */
    public static int num = 10;
}

/**
 * @author Anonymous 2023/2/24 11:49
 */
public class Demo1 {
    public static void main(String[] args) {
        // 通过类名可以直接调用当前静态成员变量
        System.out.println(A.num);

        // 当前情况下，匿名对象生命周期有且只在当前行，超出对象销毁
        new A();

        /*
        Static member 'com.qfedu.c_static.A.num' accessed via instance reference
        【警告】
            static 修饰的静态内存，通过实例化对象引用，IDE(Eclipse IDEA MyEclipse) 工具不建议

         */
        System.out.println(new A().num);

        // 对象已销毁，但是静态成员变量依然可以通过类名直接调用。
        System.out.println(A.num);
    }
}
5.3.3 static 修饰静态成员方法

语法特征:
1. 静态成员方法使用 static 修饰
2. static 修饰的静态成员方法不允许使用类内的【非静态成员】
static 修饰的静态成员方法在类文件加载阶段已具备执行能力，方法内有非静态相关内容，无法执行，因为
非静态成员需要实例化对象调用操作，加载过程中没有相关的对象存在。
3. static 修饰的静态成员方法可以直接使用类内的其他静态资源。
4. 静态成员方法常用于【工具类】方法封装
静态成员方法是可以通过类名直接调用，可以摆脱类对象的限制，执行效率较高。无需考虑对象实例化过程，以及销毁对象过程的时间和内存空间的占用浪费。
5. 静态成员方法推荐使用类名直接调用，也可以称之为【类方法】

import java.util.Arrays;

class MyArrayUtils {
    int num = 10;

    static int test = 10;

    public void test() {
        System.out.println("测试");
    }

    /**
     * 静态成员方法，降序 int 数据类型选择排序
     *
     * @param arr int 类型数组
     */
    public static void selectSortDesc(int[] arr) {
        /*
        Non-static field 'num' cannot be referenced from a static context
        static 修饰静态内容不可以引用非静态成员变量
         */
        //System.out.println(num);
        // 难兄难弟，互不嫌弃
        System.out.println(test);

        /*
        Non-static method 'test()' cannot be referenced from a static context
        static 修饰静态内容不可以引用非静态成员方法
         */
//        test();

        if (null == arr || 0 == arr.length) {
            return;
        }

        for (int i = 0; i < arr.length - 1; i++) {
            int index = i;

            for (int j = i + 1; j < arr.length; j++) {
                if (arr[index] < arr[j]) {
                    index = j;
                }
            }

            if (index != i) {
                int temp = arr[index];
                arr[index] = arr[i];
                arr[i] = temp;
            }
        }

        showArray(arr);
    }

    public static void showArray(int[] arr) {
        System.out.println(Arrays.toString(arr));
    }
}

/**
 * @author Anonymous 2023/2/24 14:50
 */
public class Demo2 {
    public static void main(String[] args) {
        int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};

        // 直接通过类名调用静态成员方法
        MyArrayUtils.selectSortDesc(arr);
        MyArrayUtils.showArray(arr);
    }
}
5.3.4 static 修饰静态代码块
  1. 静态代码块在类文件加载阶段一定执行！！！并且有且只执行一次。
  2. 静态代码块可以调用类内的其他静态资源
  3. 静态代码块不可以调用类内的非静态资源
  4. 静态代码块一般用于程序初始化操作，预处理操作，项目运行前准备工作。
    案例:
    配置资源读取
    配置文件读取
    相关资源加载
public class Demo4 {

    public int num = 10;
    public static String msg = "测试";

    // 静态代码块
    static {
        /*
        Non-static field 'num' cannot be referenced from a static context
        不可以在一个静态区域中引用非静态成员变量
        System.out.println(num);
         */
        System.out.println(msg);
        staticMethod();
        /*
        Non-static method 'test()' cannot be referenced from a static context
        不可以在一个静态区域中引用非静态成员方法
        test();
         */

        System.out.println("静态代码块资源");
    }

    public void test() {
        System.out.println("非静态成员方法");
    }

    public static void staticMethod() {
        System.out.println("静态成员方法");
    }

    public static void main(String[] args) {
        Class cls = Demo4.class;

        new Demo4();
        new Demo4();
        new Demo4();
        new Demo4();
        new Demo4();
        new Demo4();
        new Demo4();
        new Demo4();
        new Demo4();
    }

}
Jay.J.ming
关注
专栏目录
小白入门编程之路7：面向对象
fyyxc的博客
12-10 177
面向对象 一、类和对象 1、类的理解 类是一组具有共同属性和行为的事物的抽象，简单理解，类就是对【事物】的一种【描述】 描述事物，则需要【属性】和【行为】 属性：事物具备的各个特征，例如 -> 手机这个事物的特征（品牌，价格…） 行为：事物能执行的操作，例如 -> （打电话，发短信） 2、对象的理解 对象代表客观存在的事物 3、类和对象的关系理解 类是对象的抽象（描述），对象是类的实体...
java——面向对象基础
最新发布
Wooo_e的博客
02-28 1741
是一种具体步骤的操作，他是微观的。适合解决简单问题，先分析出解决问题的步 骤，然后一步一步的（用函数）去实现即可。c语言就是一个典型的面向过程的语言。结构简单，修改复杂。（程序设计越来越复杂，单纯的面向过程就难以胜任设计程序的需求，现在大多数的语言都是面向对象，c++,C#,java,python....面向对象：是指宏观上分析程序有哪些功能，然后对功能进行分类，把不同的功能封装在不同的类中。他是一种宏观的设计。代码结构：以类为组织单位。每种事物都具备自己的属性和行为/功能。类：具有。
java之面向对象基础
fanfangyu的博客
02-03 365
万物皆对象，只要是客观存在的事物都是对象类是对现实生活中一类具有共同属性和行为的事物的抽象类的特点：类是对象的数据类型类是具有相同属性和行为的一组对象的集合属性：对象具有的各种特征，每个对象的每个属性都拥有特定的值行为：对象能够执行的操作类的重要性：是Java程序的基本组成单位类是什么：是对显示生活中一类具有共同属性和行为的事物的抽象，确定对象将会拥有的属性和行为类的组成：属性和行为属性：在类中通过成员变量来体现(类中方法外的变量)行为：在类中通过。
Java之面向对象基础
weixin_44944508的博客
01-13 420
面向对象 一、对象 概念：世界上万事万物皆为对象。 具备有一定的特征（属性）和行为（方法）的事物称为对象。 属性：名词 方法：动词 例如：手机作为一个对象，属性有价格、品牌等，方法有打电话，发短信等 程序中的对象就是模拟现实中对象，以便通过程序来模拟对象之间操作，解决现实生活中的问题。 二、类 是对象的“模板”，指由具备有相同的属性和行为的事物（对象）抽象出来的一个模板。 类与对象的关系： 类是一个抽象的概念，是所有的对象相同属性和行为的一个抽象（共同体）。 对象是类的
Java 面向对象基础
wkk的博客
08-13 261
出现在成员方法、构造器中代表当前对象的地址，用于访问当前对象的成员变量、成员方法。子类出现了和父类中一模一样的方法声明，我们就称子类这个方法是重写的方法。一个java文件中可以有多个类，但是只有一个类是public的。子类可以继承父类的属性和行为，但是子类不能继承父类的构造器。当子类继承父类后，可以直接使用父类公共的属性和方法。Java中所有的类都是Object类的子类。初始化一个类的对象，并返回对象的地址。单继承模式，一个类只能继承一个父类。子类可以继承父类的私有成员，但是。关键字extends。...
Java基础——面向对象编程
05-06
Java基础——面向对象编程 面向对象编程（Object-Oriented Programming，OOP）是一种编程方法，它将现实世界中的对象抽象出来，并使用计算机模型来描述。面向对象编程的核心概念是类（class）和实例（instance）。...
8.java学习第八章——面向对象.pdf
01-20
Java 学习第八章——面向对象 #### 面向过程与面向对象的区别 在讨论面向过程和面向对象之前，我们先明确几个概念。编程语言根据其编程范式可以分为多种类型，其中面向过程和面向对象是最常见的两种。 **面向...
Java基础——面向对象基础（一）
Clannad191的博客
05-10 2610
文章目录一、Java面向对象学习的三条主线（第4-6章）：二、面向过程 vs 面向对象：三、使用"面向对象分析方法"分析问题的思路和步骤：四、面向对象的两个要素：4.1、设计类，其实就是设计类的成员4.2、类和对象的使用（面向对象思想落地的实现）五、对象的内存解析5.1、JVM内存详细图5.2、对象的内存解析 一、Java面向对象学习的三条主线（第4-6章）： Java类及类的成员：属性、方法、...
Java语言实用教程4——面向对象编程
03-04
Java程序的所有数据类型都是用类来实现的，Java语言是建立在类这个逻辑结构之上，所以Java是一种完全面向对象的程序设计语言。
Java习题——面向对象基础
Sunshine的博客
12-12 4399
1.定义一个汽车类（Car），属性有颜色，品牌，车牌号，价格，并实例化两个对象，给属性赋值，并输入属性值 //1.定义一个汽车类（Car），属性有颜色，品牌，车牌号，价格，并实例化两个对象，给属性赋值，并输入属性值 package cu.edu.nefu1; public class Car { String color; String brand; String ID; doubl...
java面向对象 基础
风雨过后的博客
01-02 757
目录 二、类与对象 三、成员变量和局部变量的区别 四、匿名对象(为了简化书写) 五、封装 六、构造方法 七、this关键字   4、自定义类 一、代码块static 1．定义 2、分类及详述 二、static 1.概念 2.特点 3.注意事项 4.静态变量(static修饰的成员变量)和非静态变量的区别 5.内存图 6.什么时候用   1.Java语言属于面...
Java面向对象基础
小白
05-10 512
文章目录JAVA 基础 面向对象什么是成员变量、局部变量、静态变量成员变量示例局部变量示例静态变量示例成员变量和静态变量的区别一句话 private 和 public构造方法例如通过构造方法初始化参数this 关键字示例一： 通过this区分成员变量 用于赋值示例二： 通过this访问成员方法静态`static`关键字含义例子`static`占内存局限性总结静态代码块示例封装优点更精确的控制成员...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值