Java学习Day16：基础篇6

为美好的生活献上中指

于 2024-07-29 18:10:05 发布

阅读量444

点赞数 13

分类专栏： Java每日学习文章标签：学习 java 开发语言算法数据结构

本文链接：https://blog.csdn.net/weixin_51721783/article/details/140761879

版权

Java每日学习专栏收录该内容

18 篇文章 0 订阅

订阅专栏

1.静态和非静态

2.调用静态和非静态的过程

注：在Java中，同类中，确实可以使用类的对象来调用静态方法，尽管这不是推荐的做法。静态方法属于类本身，而不是类的任何特定实例。因此，理论上讲，你应该通过类名来调用静态方法，而不是通过类的实例。

1.加载

开始调用之前需要将Tset类加载；

这一句的作用顺序也是先加载Static_ B类然后再在堆中创建对象static B，都需要先加载！

2.非静态掉用过程

非静态方法：需要通过类的实例（对象）来调用，也就是需要先创建类的对象，因为非静态方法属于类的实例，所以每个实例都可以有自己的非静态方法副本（尽管在大多数情况下，由于方法区共享，这只是一个概念上的说法）。非静态随着实例（对象）加载而加载；

3.静态调用过程（蓝色）

静态方法：可以直接通过类名来调用，而无需创建类的实例。这是因为静态方法属于类本身，而不是类的某个特定对象。所以使用Static_ B.mi直接调用，跳过堆区；静态成员随着类的加载而加载。

3.调用权限

静态方法：只能直接访问类的静态变量和静态方法，不能直接访问类的非静态变量和非静态方法。如果需要访问非静态成员，必须通过 类对象 = new 类 来访问。
非静态方法：可以访问类的静态变量、静态方法以及非静态变量和非静态方法，全都可以直接访问。

4.内存占用

静态方法属于类级别，理论上不占用对象的堆内存。但是，静态方法中的局部变量仍然会被存储在栈内存中。
非静态方法作为对象的一部分，虽然其方法体本身不直接占用对象的堆内存，但方法的调用（包括方法中的局部变量）会占用栈内存。

5.功能分类

1.静态方法：

通常用于工具类中的方法，这些方法不依赖于对象的状态，而是执行一些通用的操作（查询之类的）。

2.非静态方法：

通常用于表示对象的行为，这些行为可能会修改对象的状态或基于对象的状态来执行操作，特殊性使用非静态。

6.生命周期

静态方法：在类加载到JVM时就被加载到方法区，因此它的生命周期和类相同。当类被卸载时，静态方法也随之卸载。
非静态方法：不直接关联于类的加载过程。非静态方法通常在创建类的实例时，随实例一起被初始化（虽然方法的实际代码仍然存储在方法区）。当实例被销毁时，非静态方法本身并不直接销毁，但其对应的实例方法调用上下文会消失

7.成员变量

分为：

8.private

实例：

public class Teacher {
    private int  id;
    private String name;
    private int age;
    public void changeid(int a ){
         if (a<0||a>100){
             System.out.println("Nope!");
         }else {
             id=a;
             System.out.println(age);
         }
     }
    public void changename(String name1){
        if (name1.length()>3||name1.length()==0){
            System.out.println("Nope!");
        }else {
            name=name1;
            System.out.println(name);
        }
    }
    public void changeage(int age1){
        if (age1<0||age1>130){
            System.out.println("Nope!");
        }else {
            age=age1;
            System.out.println(age);
        }
    }
}

import java.util.Scanner;

public class text {
    static Scanner sc =new Scanner(System.in);
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        System.out.println("ID");
        int a=sc.nextInt();
        teacher.changeid(a);
        System.out.println("NAME");
        String name1= sc.next();
        teacher.changename(name1);
        System.out.println("AGE");
        int age1 = sc.nextInt();
        teacher.changeage(age1);
    }
}

9.this

在Java中，this关键字是一个非常重要的概念，它主要用于指代当前对象。this关键字在Java中有多种用途，但主要可以归结为以下几个方面：

引用当前对象的属性和方法：
当你需要在类的方法内部引用当前对象的成员（字段或方法）时，可以使用this关键字。这在方法中的局部变量与类的成员变量同名时特别有用，因为this可以明确指明你是在引用类的成员变量。
在构造器中调用另一个构造器：
在Java中，你可以在一个构造器中使用this()语法来调用同一个类的另一个构造器。注意，这种调用必须是构造器中的第一条语句。
返回当前对象的引用：
在某些情况下，this可以用于返回当前对象的引用。这在实现链式调用（如StringBuilder类中的方法）时非常有用。
区分隐藏的成员：
当子类从父类继承了一个成员（字段或方法），并且子类定义了同名的成员时，子类成员会隐藏父类的成员。此时，在子类中可以通过this关键字引用子类成员，通过super关键字引用父类成员。

public class Teacher {
    private int  id;
    private String name;
    private int age;

    public Teacher() {
    }

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

    public void setIid(int id ){
         if (id<0||id>100){
             System.out.println("Nope!");
         }else {
             this.id=id;
         }
     }
    public void setName(String name){
        if (name.length()>3||name.length()==0){
            System.out.println("Nope!");
        }else {
            this.name=name;
        }
    }
    public void setAge(int age){
        if (age<0||age>130){
            System.out.println("Nope!");
        }else {
             this.age=age;
        }
    }

    public int getId() {
        return id;
    }
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String toString() {
        return "Teacher{id = " + id + ", name = " + name + ", age = " + age + "}";
    }
}

import java.util.Scanner;

public class text {
    static Scanner sc =new Scanner(System.in);
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        System.out.println("ID");
        int id=sc.nextInt();
        teacher.setIid(id);
        System.out.println(teacher.getId());
        System.out.println("NAME");
        String name= sc.next();
        teacher.setName(name);
        System.out.println(teacher.getName());
        System.out.println("AGE");
        int age = sc.nextInt();
        teacher.setAge(age);
        System.out.println(teacher.getAge());
    }
}

10.构造方法

在Java中，构造方法（Constructor）是一种特殊类型的方法，用于在创建对象时初始化对象。它不具有返回类型，连void都不写。构造方法的名称必须与类名完全相同，并且可以通过不同的参数列表来重载构造方法，就像重载普通方法一样。

以下是构造方法的一些关键特点：

名称与类名相同：构造方法的名称必须与类名完全匹配。
没有返回类型：连void都不写。
主要作用是初始化：在创建对象时自动调用，用于初始化对象的成员变量。
可以被重载：一个类可以有多个构造方法，只要它们的参数列表不同即可。
默认构造方法：如果类中没有显式定义任何构造方法，则编译器会自动提供一个无参的默认构造方法。但是，一旦定义了至少一个构造方法，编译器就不会再提供默认构造方法了。

11.标准类

12.无参数构造方法应用场景

小练习：

package NumberSystem;
import java.util.Scanner;
public class NMM {
    String name;
    int count;
    double price;
    public NMM() {
    }
    NMM [] shopList =new NMM[100];
    Scanner sc = new Scanner(System.in);
    public void Caidan (){
        for (;;) {
            System.out.println("------欢迎使用数据库管理系统------");
            System.out.println("1：Check Data");
            System.out.println("2：Change Date");
            System.out.println("3：Add Date");
            System.out.println("4：Del Date");
            System.out.println("5：Display All");
            System.out.println("6：Quit");
            System.out.println("输入编号：");
            int num = sc.nextInt();
            int temp = 0;
            if (num==1){
                System.out.println("正在使用数据查询功能，请输入name：");
                String name =sc.next();
                getMessage(name);
            }//1.查询功能
            if (num==2){
                System.out.println("正在使用数据修改功能，请输入name：");
                String name =sc.next();
                update(name);
            }//修改数据功能
            if (num==3){
                System.out.println("正在使用数据录入功能，请输入name：");
                String name =sc.next();
                System.out.println("正在使用数据录入功能，请输入count：");
                int count =sc.nextInt();
                System.out.println("正在使用数据录入功能，请输入price：");
                double price = sc.nextDouble();
                add(name,count,price);
            }//添加数据功能
            if (num == 4) {
                System.out.println("正在使用数据删除功能，请输入name：");
                String name =sc.next();
                del(name);
            } //删除数据功能
            if (num==5){
                for (int i = 0; i < shopList.length; i++) {
                    if (shopList[i] != null) { // 首先检查 shopList[i] 是否为 null
                        if (shopList[i].getName() != null) {
                            String na = shopList[i].getName();
                            int con = shopList[i].getCount();
                            double pri = shopList[i].getPrice();
                            String str = toString(na, con, pri); // 假设 toString 是一个有效的方法
                            System.out.println(str);
                        } else {
                            // 这里处理 getName() 返回 null 的情况
                            System.out.println("位置 " + i + " 的商品名称为 null");
                            break;
                        }
                    } else {
                        // 这里处理 shopList[i] 为 null 的情况
                        System.out.println("位置 " + i + " 的整个商品对象为 null");
                        break;
                    }
                }
            }
            if (num==6){
                break;
            }//跳出循环
        }
    }

    private void del(String name) {
        for (int i = 0; i< shopList.length; i++) {
            if(shopList[i].getName().equals(name)){
                shopList[i].setName(null);
                shopList[i].setCount(0);
                shopList[i].setPrice(0.0);
                System.out.println("删除成功!");
                break;
            }
        }
    }//删除数据

    private void update(String name) {
        for (int i = 0; i< shopList.length; i++) {
            if(shopList[i].getName().equals(name)){
                System.out.println("正在使用数据修改功能，请输入修改后的name：");
                String na =sc.next();
                System.out.println("正在使用数据修改功能，请输入修改后的count：");
                int con =sc.nextInt();
                System.out.println("正在使用数据修改功能，请输入修改后的price：");
                double pri = sc.nextDouble();
                shopList[i].setName(na);
                shopList[i].setCount(con);
                shopList[i].setPrice(pri);
                String str= toString(na,con,pri);
                System.out.println(str);
                break;
            }
        }
    }//更新数据模块

    private void getMessage(String name) {
        for (int i = 0; i< shopList.length; i++) {
            if(shopList[i].getName().equals(name)){
                String na= shopList[i].getName();
                int con =shopList[i].getCount();
                double pri= shopList[i].getPrice();
                String str= toString(na,con,pri);
                System.out.println(str);
                break;
            }
    }
}//查询模块

    private void add(String name,int count,double price) {
        for (int i = 0; i< shopList.length; i++) {
            if(shopList[i]==null){
                shopList[i]=new NMM();//初始化！！！！！！！！！！！
                shopList[i].setName(name);
                shopList[i].setCount(count);
                shopList[i].setPrice(price);
                String str= toString(shopList[i].getName(),shopList[i].getCount(),shopList[i].getPrice());
                System.out.println(str);
                break;
            }
            System.out.println(shopList[i]);
        }
    }//添加模块





    public String toString(String name,int count ,double price) {
        return "添加后数据：{name = " + name + ", count = " + count + ", price = " + price + "}";
    }
    public NMM(String name, int count, double price) {
        this.name = name;
        this.count = count;
        this.price = price;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getCount() {
        return count;
    }
    public void setCount(int count) {
        this.count = count;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }

}

为美好的生活献上中指

关注

13
点赞
踩
11

收藏

觉得还不错? 一键收藏
0
评论
Java学习Day16：基础篇6

return "添加后数据：{name = " + name + ", count = " + count + ", price = " + price + "}";System.out.println("位置 " + i + " 的商品名称为 null");这是因为静态方法属于类本身，而不是类的某个特定对象。System.out.println("正在使用数据修改功能，请输入修改后的price：");System.out.println("正在使用数据修改功能，请输入修改后的name：");
复制链接

扫一扫

专栏目录