Day02_数组与面向对象

最新推荐文章于 2024-04-25 17:40:14 发布
最新推荐文章于 2024-04-25 17:40:14 发布
阅读量221 收藏
点赞数
文章标签： java 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41600544/article/details/128242865
版权

Day02-数组与面向对象

一、数组
1：概念

和Python中一样, Java中也是有用来同时存储多个同类型元素的容器的, 那就是: 数组.

在一个数组中，数据元素的类型是唯一的，即一个数组中的元素的类型相同

2：格式

​ 静态初始化：我们给定初始化值, 由系统指定长度

​ 格式1：数据类型[] 数组名=new 数据类型[]{元素1,元素2,元素3…};

​ 格式2：数据类型[] 数组名={元素1,元素2,元素3…};

​ 动态初始化：我们给定长度, 由系统给出默认初始化值.

​ 格式1:数据类型[] 数组名 = new 数据类型[长度];

​ 格式2:数据类型 数组名[] = new 数据类型[长度];

public class ArrayDemo01 {
    public static void main(String[] args) {
        //1. 创建int类型的数组, 用来存储3个元素.
        //我们制定长度, 由系统给出默认值.
        //格式一:
        int[] arr1 = new int[3];		//推荐.
        //格式二:
        int arr2[] = new int[3];

        //2. 创建int类型的数组, 存储数据`11, 22, 33`.
       //我们直接传入元素, 由系统指定长度.
       //格式1
       int[] arr3 = new int[]{11, 22, 33};
       //格式2
       int[] arr4 = {11, 22, 33};		//推荐.
   }
3：格式详解

​ 数据类型[] 数组名 = new 数据类型[长度];

​ 数据类型：限制数组中只能存对应类型的数据

​ [ ]：①代表是数组类型 ②限制长度

​ 数组名：方便调用数组

​ new：关键字,创建对象的,new出来会在堆内存开辟一块空间

​ { }：存放元素的

4：常见操作

​ 访问数组元素：数组名[索引]

​ 修改数组元素：数组名[索引]=值;

​ 获取数组长度：数组名.length

1、访问数组元素：数组名[索引]
  int[] arr = {11, 22, 33};
  System.out.println(arr[0]);	//打印结果是: 11
2、修改数组元素：数组名[索引]=值;
  int[] arr = {11, 22, 33};
  System.out.println(arr[1]);	//打印结果是: 22
  arr[1] = 222;
  System.out.println(arr[1]);	//打印结果是: 222
3、通过数组名.length的方式, 可以获取数组的长度.
  int[] arr = {11, 22, 33};
  System.out.println(arr.length);	//打印结果是: 3
5：数组案例
需求：
定义一个长度为5的int类型的数组.
打印数组中的第3个元素.
设置数组中的第一个元素值为11.
获取数组中的第一个元素值, 并将其赋值给变量a, 然后打印.
打印数组的长度. 

public class ArrayDemo02 {
    public static void main(String[] args) {
        //1. 定义一个长度为5的int类型的数组.
        int[] arr = new int[5];
        //2. 打印数组中的第3个元素.
        System.out.println(arr[2]);
        //3. 设置数组中的第一个元素值为11.
        arr[0] = 11;
        //4. 获取数组中的第一个元素值, 并将其赋值给变量a, 然后打印.
        int a = arr[0];
        System.out.println(a);
        //5. 打印数组的长度.
        System.out.println(arr.length);
    }
}
6：数组内存图
6-1 JVM的内存划分

​ 栈: 存储局部变量以及所有代码执行的.

​ 局部变量: 指的是定义在方法中, 或者方法声明上的变量.

	 特点: 先进后出.

​ 堆: 存储所有new出来的内容(即: 对象).

​ 特点: 堆中的内容会在不确定的时间, 被GC回收.

​ 方法区: 存储字节码文件的.

​ 字节码文件: 指的是后缀名为.class的文件.

​ 本地方法区:

​ 和系统相关, 了解即可.

​ 寄存器

	和CPU相关, 了解即可.
6-2 数据内存案例
public class ArrayDemo03 {
      public static void main(String[] args) {
		int arr={10,20,30};
        System.out.print(arr[1]);
        arr[1]=22;
        System.out.print(arr[1]);
		int length=arr.length;
        System.out.print(length);
	}
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-isKoGoEG-1670500700088)(…/img/数据内存图.png)]

7：两个小问题

​ 问题一：数组索引越界异常(ArrayIndexOutOfBoundsException)

​ 产生原因：访问了数组中不存在的索引.

​ 解决方案：访问数组中存在的索引即可.

​ 问题二：空指针异常(NullPointerException)

​ 产生原因：访问了空对象. 即: 对象为空, 你还去调用它的一些方法, 肯定不行.

​ 解决方案：对对象赋具体的值即可.

案例一：演示数组越界

需求：
定义int类型的数组, 存储元素11, 22.
打印数组中的第2个元素. 
尝试打印数组中的第3个元素

public class ArrayDemo06 {
    public static void main(String[] args) {
        //1. 定义int类型的数组, 存储元素11, 22.
        int[] arr = {11, 22};
        //2. 打印数组中的第2个元素.
        System.out.println("arr[1]: " + arr[1]);
        //3. 尝试打印数组中的第3个元素.
        System.out.println("arr[2]: " + arr[2]);
    }
}

案例二：演示空指针异常

需求：
定义int类型的数组, 存储元素11, 22.
将null(空常量)赋值给数组.
尝试打印数组的第一个元素. 
    
public class ArrayDemo07 {
    public static void main(String[] args) {
        //1. 定义int类型的数组, 存储元素11, 22.
        int[] arr = {11, 22};
        //2. 将null(空常量)赋值给数组.
        arr = null;
        //3. 尝试打印数组的第一个元素.
        System.out.println("arr[0]: " + arr[0]);
    }
}
二、方法
1：概念

Python中的函数, 是将具有独立功能的代码块组织成为一个整体，使其成为具有特殊功能的代码集.

Java中也是如此, 只不过, Java中的函数也叫方法.

2：格式
修饰符 返回值的数据类型 方法名(参数类型 参数名1, 参数类型 参数名2) { //这里可以写多个参数
    //方法体;
    return 具体的返回值;	//加工好的饲料
}

public static void main(String[] args) {
   
}
3：格式详解

• 修饰符: 目前记住这里是固定格式public static

• 返回值的数据类型: 用于限定返回值的数据类型的.

注意:

​ 返回值的数据类型是int类型, 则说明该方法只能返回int类型的整数.

​ 如果方法没有具体的返回值, 则返回值的数据类型要用void来修饰.

• 方法名: 方便我们调用方法.

•参数类型: 用于限定调用方法时传入的数据的数据类型. 注意：参数类型是String类型, 说明我们调用方法时, 只能传入字符串.

• 参数名: 用于接收调用方法时传入的数据的变量.

• 方法体: 完成特定功能的代码.

• return 返回值: 用来结束方法的, 并把返回值返回给调用者.

解释: 如果方法没有明确的返回值, 则return关键字可以省略不写.

4：注意事项

​ ①方法与方法之间是平级关系, 不能嵌套定义.

​ ②方法必须先创建才可以使用, 该过程称为: 方法定义.

​ ③方法自身不会直接运行, 而是需要我们手动调用方法后, 它才会执行, 该过程称为方法调用.

​ ④定义方法的时候写在参数列表中的参数, 都是: 形参.; 形参: 形容调用方法的时候, 需要传入什么类型的参数.

​ ⑤调用方法的时候, 传入的具体的值(变量或者常量都可以), 叫实参.; 实参: 调用方法时, 实际参与运算的数据.

5：常见操作

案例一：数据遍历

需求：
定义方法printArray(), 接收一个int类型的数组.
通过该方法, 实现遍历数组的功能. 
在main方法中, 调用方法, 打印指定的数组. 
    
public class MethodDemo01 {
    public static void main(String[] args) {
        int[] arr = {13,5,7,9};
        printArray(arr);
    }
    /**
     * 打印输出数组的值
     * @param arrs
    */
   public static void printArray(int[] arrs){
       for (int i = 0; i <arrs.length; i++) {
           System.out.println(arrs[i]);
        }
    }
}

案例二：获取数组的最值

需求

定义方法getMax(), 接收一个int类型的数组.

通过该方法, 获取数组元素中的最大值. 

在main方法中, 调用方法, 打印对应的结果. 

public class MethodDemo04 {
    public static void main(String[] args) {
        int[] arrs = {1, 3, 5, 7, 9, 2, 4, 6, 8};
        //调用方法获取最大值
        int max = getMax(arrs);
        //打印输出结果
        System.out.println(max);
    }

   /**
     * 获取数组最大的值
     *
     * @param arrs 数组结合
     * @return
     */
    public static int getMax(int[] arrs) {
        int temp = arrs[0];
        for (int i = 1; i < arrs.length; i++) {
            int element = arrs[i];
            if (temp < element) {
                temp = element;
            }
        }
        return temp;
    }
}

6：方法的重载

概念：同一个类中, 出现方法名相同, 但是参数列表不同的两个或以上的方法时称为方法重载. 方法重载与方法的返回值的数据类型无关.

注意: 参数列表不同分为两种情况

参数的个数不同.

对应参数的数据类型不同.

案例：

需求

定义方法compare(), 用来比较两个整型数据是否相等. 

要求兼容所有的整数类型, 即(byte, short, int, long)

public class MethodDemo01 {
    public static void main(String[] args) {
        //定义不同数据类型的变量
        byte a = 10;
        byte b = 20;
        short c = 10;
        short d = 20;
        int e = 10;
        int f = 10;
        long g = 10;
        long h = 20;
        // 调用
        System.out.println(compare(a, b));
        System.out.println(compare(c, d));
        System.out.println(compare(e, f));
        System.out.println(compare(g, h));
    }

    // 两个byte类型的
    public static boolean compare(byte a, byte b) {
        System.out.println("byte");
        return a == b;
    }

    // 两个short类型的
    public static boolean compare(short a, short b) {
        System.out.println("short");
        return a == b;
    }

    // 两个int类型的
    public static boolean compare(int a, int b) {
        System.out.println("int");
        return a == b;
    }

    // 两个long类型的
    public static boolean compare(long a, long b) {
        System.out.println("long");
        return a == b;
    }
}
三、面向对象
1：概念

和Python一样, Java也是一门以面向对象为编程思想的语言, 也有类, 对象的概念, 并且面向对象的三大特征: 封装, 继承, 多态, 在Java中也都是有的, 接下来, 我们来研究下Java中的面向对象应该如何运用.

2：类和对象解释

​ 类: 是属性和行为的集合, 是一个抽象的概念, 看不见, 也摸不着.

​ 对象: 是类的具体体现, 实现.

​ 属性: 也叫字段, 成员变量, 就是事物的描述信息(名词).

​ 行为: 也叫成员方法, 指的就是事物能够做什么.

​ 例如: 学生类的属性和行为如下

​ 1) 属性: 姓名, 年龄, 性 别…

​ 2) 行为: 学习, 吃饭, 睡觉…

3：类的格式定义

​ 定义类其实就是定义类的成员(成员变量和成员方法)

• 成员变量:

​ 1) 和以前定义变量是一样的, 只不过位置发生了改变, 写到类中, 方法外

​ 2) 而且成员变量还可以不用赋值, 因为它有默认值.

• 成员方法:

​ 1) 和以前定义方法是一样的, 只不过把static关键字去掉.（这点先记忆即可, 后面再讲解static关键字的用法.）

定义类的格式：

​ public class 类名 {
​ //成员变量, 私有化, 类似于Python中的 __

​ //构造方法, 空参, 全参, 类似于Python的魔法方法之 init(self)

​ //getXxx(), setXxx()方法, 用来获取或者设置对象的属性值的
//成员方法, 就是普通的函数
}

使用类找中成员的格式

​ 所谓类的使用, 就是使用类中定义的成员(成员变量和成员方法).

格式：

创建该类的对象, 格式如下: 
类名 对象名 = new 类名();

通过对象名.的形式, 调用类中的指定成员即可, 格式如下: 

//成员变量
对象名.成员变量
  
//成员方法
对象名.成员方法(参数列表中各数据类型对应的值...)
3：类的案例

需求：

  1. 定义学生类Student

属性: 姓名(name),年龄(age)

行为: 学习(study)

  1. 创建测试类StudentTest, 在类中定义main方法, 并访问学生类(Student类)中的成员.

定义学生类

//1)学生类
public class Student { 
    //1.成员变量(属性)
   private  String name;
   private int age;
    //2.构造方法 类似于 python __init__ ，初始化类的属性，给属性赋值
    //构造方法要求：
    // 1.必须要和类名一模一样
    // 2.参数列表可以为空，0~多个
    // 3.不能返回类型，void 都不能有
    // this 代表是当前对象
    //构造方法默认情况下，会自动提供无参构造方法，如果创建了一个有参构造，无参构造就需要自己创建。
    //构造方法就是做初始化的方法，给变量赋值
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //3.成员方法(行为)

	public void study() {
         System.out.println("好好学习,天天向上");
   }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        //需求1:空参构造
        Student s1 = new Student();
        //给对象属性赋值
        s1.setName("张三");
        s1.setAge(18);
        //打印对象属性值
        System.out.println("姓名:"+s1.getName()+",年龄:"+s1.getAge());
        s1.study();
        System.out.println("--------------------");
        //需求2:满参构造,直接赋值
        Student s2 = new Student("李四",28);
        //打印对象属性值
        System.out.println("姓名:"+s2.getName()+",年龄:"+s2.getAge());
        s2.study();
    }

}
4：封装

封装是面向对象编程思想的三大特征之一, 所谓的封装指的就是隐藏对象的属性和实现细节, 仅对外提供一个公共的访问方式.

记忆:

面向对象的三大特征: 封装, 继承, 多态.

问题一: 怎么隐藏?

​ 答案: 通过private关键字实现.

问题二: 公共的访问方式是什么?

​ 答案:** getXxx()和setXxx()方法

4-1：private关键字

概念：private是一个关键字, 也是访问权限修饰符的一种, 它可以用来修饰类的成员(成员变量和成员方法).

特点：被private修饰的内容只能在本类中直接使用.

开发场景：

  1. 在实际开发中, 成员变量基本上都是用private关键字来修饰的.

  2. 如果明确知道类中的某些内容不想被外界直接访问, 都可以通过private来修饰.

4-2：this关键字

概念：this代表本类当前对象的引用, 大白话翻译: 谁调用, this就代表谁.

场景：用来解决局部变量和成员变量重名问题的.

//学生类

public class Student {
    int age = 20;

    public void show() {
        int age = 30;
        //打印结果是什么呢? 如果要另外一个结果怎么办?
        System.out.println(age);    
    }
}
//测试
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.show();
    }
}

总结：Java中, 使用变量遵循就近原则, 局部位置有就使用, 没有就去本类的成员位置找, 有就使用, 没有就报错.

解释: 先这么记忆, 不严谨, 因为本类没有, 还会去父类中查找, 这点在继承部分再解释.

4-3：构造方法

概念：Java中的构造方法类似于Python中的魔法方法之__init__(), 就是用来创建对象的, 捎带着可以给对象的各个成员变量赋值.

场景： 构造方法就是用来快速对对象的各个属性赋值的.

格式：

格式要求：
1. 构造方法名必须和类名完全一致(包括大小写).
2. 构造方法没有返回值类型, 连void都不能写.
3. 构造方法没有具体的返回值, 但是可以写return(实际开发, 一般不写).

public   类名(参数类型 参数名1, 参数类型 参数名2) {  //这里可以写多个参数.*
    *//给对象的各个属性赋值即可.*
}

注意：

  1. 如果我们没有给出构造方法, 系统将给出一个默认的无参构造供我们使用.

  2. 如果我们给出了构造方法, 系统将不再提供默认的构造方法给我们使用.

    1. 这个时候, 如果我们还想使用无参构造, 就必须自己提供.

    2. 建议定义类时, 我们给出无参构造, 方便用户调用(实际开发都这么做的).

5：继承

概念：多个类中存在相同属性和行为时, 将这些内容抽取到单独的一个类中, 那么这多个类就无需再定义这些属性和行为了, 只要继承那个类即可. 这个关系, 就叫继承, Java中,类与类之间的继承只能单继承,不能多继承,但是可以多层继承.

格式：

public class 类A extends 类B {	*//子承父业*
    
}
解释:
• 类A: 叫子类, 或者派生类.
• 类B: 叫父类, 基类, 或者超类.
我们一般会念做: 子类和父类.

案例

需求
1. 按照标准格式定义一个人类(Person类), 属性为姓名和年龄. 
2. 定义老师类(Teacher), 继承自人类, 并在老师类中定义teach()方法.
3. 定义学生类(Student), 继承自人类, 并在学生类中定义study()方法.
   在PersonTest测试类的main方法中, 分别创建老师类和学生类的对象, 并调用各自类中的成员.

public class Person {
    //成员变量
    private String name;
    private int age;
    //成员方法
    public String getName() {
        return name;
    }
   public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    //构造方法
    public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

子类继承父类

public class Student extends Person{

}

public class Teacher extends Person{

}

Test

public class test {
    public static void main(String[] args) {
        //创建Stduent对象
        Student s =new Student();
        //调用子类继承父类方法
        s.setName("java");
        s.setAge(23);
        System.out.println(s.getName()+s.getAge());
        //创建Teacher对象
        Teacher t =new Teacher();
        t.setName("python");
        t.setAge(34);
        System.out.println(t.getName()+t.getAge());
    }
}

继承好处&弊端

好处：

  1. 提高了代码的复用性.

  2. 提高了代码的可维护性.

  3. 让类与类之间产生关系, 是多态的前提.

弊端：

​ 让类与类之间产生了关系, 也就让类的耦合性增强了.

​ 解释:

​ 开发原则: 高内聚, 低耦合.

​ • 内聚: 指的是类自己独立完成某些事情的能力.

​ • 耦合: 指的是类与类之间的关系.

public class Father {
    int age = 30;
}

public class Son extends Father{
    int age=20;
    public void show(){
        int age=10;
        System.out.println("age:"+age);//10
        System.out.println("this.age:"+this.age);//20
        System.out.println("super.age:"+super.age);
    }
}

public class Test {
    public static void main(String[] args) {
        Son s = new Son();
        s.show();  //猜下运行结果是多少?
    }
}

总结：

  1. Java中调用成员变量遵循就近原则, 局部位置有就使用, 没有就去本类的成员位置找. 有就使用, 没有就去父类的成员位置找, 有就使用, 没有就报错.

注意: 不考虑父类的父类这种情况, 因为会一直往上找, 直到把所有的父类都找完, 还找不到, 就报错了.

  1. this: this代表本类对象的引用

  2. super: super代表父类对象的引用

5-2 方法重写

概念：子类中出现和父类一模一样的方法时, 称为方法重写. 方法重写要求返回值的数据类型也必须一样.

场景：当子类需要使用父类的功能, 而功能主体又有自己独有需求的时候, 就可以考虑重写父类中的方法了, 这样, 即沿袭了父类的功能, 又定义了子类特有的内容.

案例：

需求

  1. 定义Phone类, 并在类中定义call(String name)方法.

  2. 定义NewPhone类, 继承Phone类, 然后重写call(String name)方法.

  3. 在PhoneTest测试类中, 分别创建两个类的对象, 然后调用call()方法, 观察程序执行结果. //手机类

    public class Phone {
    public void call(String name){
        System.out.println("给"+name+"打电话");
    }
}
//新式手机类,在旧手机类的基础上加上彩铃功能
public class NewPhone extends Phone{
    @Override
    public void call(String name) {
        super.call(name); //父类功能
        //加入自己独有的功能
        System.out.println("新增彩铃功能");
    }
}

//测试类

public class Test {
    public static void main(String[] args) {
        new Phone().call("张三");
        System.out.println("--------------------");
        new NewPhone().call("李四");
    }
}

    注意：

    1. 子类重写父类方法时, 方法声明上要用@Override注解来修饰.

    2. 父类中私有的方法不能被重写.

    3. 子类重写父类方法时, 访问权限不能更低

6、多态
6-1概念

​ 多态指的是同一个事物(或者对象)在不同时刻表现出来的不同状态.

​ 例如: 一杯水.

​ • 常温下是液体.

​ • 高温下是气体.

6-2前提条件

​ 要有继承关系.

​ 要有方法重写.

​ 要有父类引用指向子类对象.

6-3 多态案例
需求
1.定义动物类Animal, 并在类中定义一个成员方法: eat()
2.定义猫类Cat, 继承Animal类, 并重写eat()方法.
3.在AnimalTest测试类的main方法中, 通过多态的方式创建猫类对象.
4.通过猫类对象, 调用eat()方法. 

1.定义动物类 Animal
public class Animal {
    public void eat(){
        System.out.println("动物吃...");
    }
}

2.定义猫类 Cat
public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

3.定义AnimalTest 类，并调用 eat() 方法
public class AnimalTest {
    public static void main(String[] args) {
        Animal cat = new Cat();
        //调用 eat 方法
        cat.eat();
    }
}

多态的好处&弊端

好处：提高了程序的扩展性.

弊端：父类引用不能访问子类的特有功能.

​ 问： 那如何解决这个问题呢?

​ 答: 通过向下转型来解决这个问题.

向上转型、向下转型

7、final关键字
7-1概念

final是一个关键字, 表示最终的意思, 可以修饰类, 成员变量, 成员方法.

• 修饰的类: 不能被继承, 但是可以继承其他的类.

• 修饰的变量: 是一个常量, 只能被赋值一次.

• 修饰的方法: 不能被子类重写.

7-2案例

需求
1.定义Father类, 并定义它的子类Son. 
2.先用final修饰Father类, 看Son类是否还能继承Father类.
3.在Father类中定义show()方法, 然后用final修饰, 看Son类是否能重写该方法. 
4.在Test类中定义成员变量a,, 并用final修饰, 然后尝试给其重新赋值
运行程序,观察结果

public final class Father {
    public final  void show(){
        System.out.println("father_show");
    }
}
public class Son extends Father {//此行报错,final修饰的类: 不能被继承
    @Override
    public void show() {//此行报错,final修饰的方法,不能被子类重写
        super.show();
    }
}
public class Test {
    public static void main(String[] args) {
	Son s = new Son();
	s.show();
        final int a=10;
        a=20;//此行报错,final修饰的变量,是常量,只能被赋值1次
        System.out.println(a);
    }
}
8、static关键字
8-1 概念

static是一个关键字, 表示静态的意思, 可以修饰成员变量, 成员方法.

8-2 特点

  1. 随着类的加载而加载.

  2. 优先于对象存在.

  3. 被static修饰的内容, 能被该类下所有的对象共享.

    解释: 这也是我们判断是否使用静态关键字的条件.

  4. 可以通过**类名.**的形式调用.

需求
定义学生类, 属性为姓名, 年龄, 毕业院校(school).
1.在学生类中定义show()方法, 用来打印上述的各个属性信息.
2.在测试类的main方法中, 创建学生对象, 并调用学生类的各个成员. 
参考代码
//学生类
public class Student {
    private String name;
    private int age;
    private static String school;

    public Student() {
    }
    public Student(String name, int age, String school) {
        this.name = name;
        this.age = age;
        this.school = school;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getSchool() {
        return school;
    }
    public void setSchool(String school) {
        this.school = school;
    }
}


//测试类
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("张三", 18, "北京大学");
        Student s2 = new Student("李四", 18, "传智大学");
        System.out.println(s1.getSchool());
        System.out.println(s2.getSchool());
    }
}

8-3 静态方法注意事项

• 访问特点

静态方法只能访问静态的成员变量和静态的成员方法.

简单记忆: 静态只能访问静态.

• 注意事项

​ 在静态方法中, 是没有this, super关键字的.

​ 因为静态的内容是随着类的加载而加载, 而this和super是随着对象的创建而存在.

即: 先进内存的, 不能访问后进内存的.

//学生类
public class Student {
     String name;
     static String school;
     public void show1(){
         //结论1: 非静态方法可以访问所有成员(非静态变量和方法, 静态变量和方法)
         System.out.println(name);
         System.out.println(school);
         show2();
         show4();
     }
    public void show2(){
        System.out.println("非静态方法show2");
    }
    public static void show3(){
        //结论2: 静态只能访问静态成员
        //System.out.println(name);//此行报错,静态只能访问静态
        System.out.println(school);
        //show2();//此行报错,静态只能访问静态
        show4();
    }
    public static void show4(){
        System.out.println("静态方法show4");
    }
}

//测试类
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.show1();
        System.out.println("------------");
        Student.show3();//静态方法可以通过类名直接调用
    }
}
weixin_41600544
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数组
mujinhuanian的博客
11-29 194
数组 一、定义 数组是一组相同类型的变量。 二、创建数组 int[] array1 = {1,2,3,4,5}; int[] array2 = new int[]{1,2,3,4,5}; int[] array3 = new int[5]; 三、遍历数组（3种方式） //方式一for循环 for(int i = 0; i<array1.length;i++){ int ret = array1[i]...
Javaday02训练
02-08
封装是面向对象编程的一个重要原则，它隐藏了对象的内部细节，只通过公共接口与外界交互，提高了代码的安全性和可维护性。 继承是另一个关键概念，它允许一个类（子类）继承另一个类（父类）的属性和方法。这增强了...
定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，并在控制台输出结果。
Lazybone2020的博客
05-30 1795
public class Test { public static void main(String[] args) { int[] arr = {1,2,3,4,5}; printArray(arr); } public static void printArray(int[] arr){ for (int i = 0; i < arr.length; i++) { if(i==0){
Java数组的定义与使用
weixin_44070116的博客
11-05 1236
Java数组的定义与使用
2021-07-10
weixin_52332483的博客
07-11 126
数组 数组的基本特点 长度确定，一旦被创建，数组的大小就不可以被改变 其元素必须是同类型 数组的元素可以是任何类型，包括基本类型和引用类型 数组变量属于引用类型，数组本身就是对象，数组中的每个元素都相当于该对象的成员变量 java中对象在堆中。 如何创建数组 数组使用new关键字创建，元素通过索引来访问，数组索引从0开始，通过数组名.length来获取数组长度。 举例： public class ArrayDemo01 { public static void main(String[] arg
JavaEE
ZhaoZhiXinLiMiao的博客
11-01 311
Day06 一维数组的应用 数组的遍历(将数组中的元素一一输出出来) 1.自定义数组 int[ ] arr = {11,22,33,44,55} ; 2.数组中的属性:length 数组中的最大索引值:arr.length-1 在这里插入代码片 ...
day3_php审计学习day1_
10-01
...它的设计目标是简化网页开发，现在已经成为...这只是PHP审计学习的第一天，我们将逐步学习更多高级主题，如面向对象编程、模板引擎、安全实践等。通过持续学习和实践，你将掌握PHP编程，能够构建自己的Web应用程序。
day20_字节流、字符流、属性集.pdf
11-02
IO流的设计遵循了面向对象的原则，提供了许多子类来适应不同的需求，如过滤流（Filter Stream），缓冲流（Buffered Stream），转换流（InputStreamReader/OutputStreamWriter）等。过滤流可以添加到已存在的流之上，...
Java_day02上课资料.zip
03-24
4. **类与对象**：深入讲解Java的面向对象特性，包括类的定义、对象的创建、封装、继承、多态等概念。 5. **数组与集合**：介绍如何使用一维和多维数组，以及Java集合框架，如ArrayList、LinkedList、HashSet、...
day210314_fortran90_
10-02
Fortran 90是Fortran语言的一个重要版本，它引入了许多现代化的编程特性，如模块化、数组处理和面向对象编程的初步支持，使得代码更加简洁和易读。 以下是一个简单的示例，展示了如何使用Fortran 90的for循环来计算...
java--方法(含debug调试)
qq_46893497的博客
01-22 904
方法1. 方法简介1.1 概述1.2 定义格式1.3 格式解释1.4 注意事项1.5 方法的好处2. 无参无返回值的方法2.1 定义无参无返回值的方法2.2 调用无参无返回值的方法2.3 方法调用图解2.4 示例一: 打印10次HelloWorld2.5 示例二: 打印奇偶数3. 有参无返回值的方法3.1 示例一: 定义求和方法3.2 示例二: 判断奇偶数3.3 实例三: 获取最大值4. 无参有返回值的方法4.1 示例一: 定义求和方法4.2 示例二: 判断奇偶数4.3 实例三: 获取最小值5. 有参有返回
Java学习(十五)：Java泛型
qq_36212439的博客
09-13 198
Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。 泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。 假定我们有这样一个需求：写一个排序方法，能够对整型数组、字符串数组甚至其他任何类型的数组进行排序，该如何实现？ 答案是可以使用 Java 泛型。 使用 Java 泛型的概念，...
Java 泛型
笔记
03-20 274
Java泛型是Java语言中一个非常重要的特性。它可以让我们编写更加安全、可读性更好和更易于维护的代码。在实际工作中，我们可以使用Java泛型来实现通用的代码，而不用考虑数据类型的具体实现。希望这篇文章可以帮助你更好地理解Java泛型的作用和用途。
Java-EE-泛型
最新发布
qq_43156057的博客
04-25 1061
Java引入泛型主要是为了提高类型安全性和代码的可读性。
泛型
weixin_43917654的博客
06-02 168
Java泛型 Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。 泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。 假定我们有这样一个需求：写一个排序方法，能够对整型数组、字符串数组甚至其他任何类型的数组进行排序，该如何实现？ 答案是可以使用Java 泛型。 使用 Ja...
数组方法练习：定义方法按格式输出数组元素
qq_45044028的博客
06-12 466
public class ArrList { public static void main(String[] args) { int[] arr = {11,22,33,44,55}; printArray(arr); } public static void printArray(int[] arr){ System.out.print("["); for (int i = 0; i < arr.len...
数组&方法
okbin1991的博客
10-13 217
1. 数组简介 1.1 概述 我们之前学习的变量或者是常量, 只能用来存储一个数据, 例如: 存储一个整数, 小数或者字符串等. 如果需要同时存储多个同类型的数据, 用变量或者常量来实现的话, 非常的繁琐. 针对于这种情况, 我们就可以通过数组来实现了. 例如: 假设某公司有50名员工, 现在需要统计该公司员工的工资情况, 例如计算平均工资、获取最高工资等。针对于这个需求，如果用前面所学的知识...
JavaSe基础XX03——数组
雨一直下
08-04 435
数组定义的格式1： int arr[] = new int[3];
java基础：使用泛型方法输出Integer, Double 和 Character类型的数组
qq_40378795的博客
10-21 1508
public class GenericMethodTest { // 泛型方法 printArray public static < E > void printArray( E[] inputArray ) { // 输出数组元素 for ( E element : inputArray ){ System.out.printf(.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值