JavaSE-方法、this 指向、（非）静态代码块

已于 2022-05-26 10:38:47 修改
阅读量136 收藏
点赞数
文章标签： java
于 2022-05-26 10:38:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/errrl/article/details/124980101
版权

JavaSE-方法、this 指向、（非）静态代码块

方法定义

修饰符 返回值类型 方法名(参数类型,参数名){
	...
	方法体
	...
	return 返回值;
}

  • 修饰符：可选常用public / static。

  • 返回值类型：方法可能会存在返回值。returnValueType是方法的返回值的类型。有返回至请根据返回类型进行设置（基本数据类型），无返回值则void。

  • 方法名：遵循驼峰命名法，见名知意。

  • 参数类型：参数就是一个占位符，当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数可选，方法可以不包含任何参数。

    • 形参：在方法被调用时用于接受外界输入的参数。

    • 实参：调用方法时实际传给方法的参数。

  • 方法体：定义功能。

静态方法与非静态方法

静态方法与非静态方法的区别

静态方法和类一起加载，不能直接调用非静态方法。

静态方法可以通过类调用或者在main 方法中可以直接调用。

非静态方法与实例化对象相关，需要实例化对象后才能被调用。

public class Demo{
	public static void main(String[] args){
		fn();  // error "Non-static method 'say()' cannot be referenced from a static context"
		Demo.fn();  // error "Non-static method 'say()' cannot be referenced from a static context"
		fn2();  // 调用了静态方法
		Demo demo = new Demo();
		demo.fn(); // 调用了非静态方法
		demo.fn3(); // 调用了非静态方法
		Demo.fn2();  // 调用了静态方法
	}
	public void fn(){
		System.out.println("调用了非静态方法")
	}
	puclic static void fn2(){
		System.out.println("调用了静态方法")
	}
	public void fn3(){
		fn1(); // 非静态方法是可以互相调用的。
	}
}

方法调用

  1. 静态方法的调用
public class Main{
	public static void main(String[] args){
		Main.test();
		test();
	}
	public static void test(){
		
	}
}
  1. 非静态方法的调用
public class Main{
	public static void main(String[] args){
		Main main = new Main();
		main.test();
	}
	public void test(){
		
	}
}

方法重载

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0ovcJtDs-1653532454463)(imgclip.png “imgclip.png”)]

public class Main{
	public static void main(String[] args){
		test(10.0,10.0);
		test(10,20);
	}
	public static void test(int a,int b){
		System.out.println(a+','+b);
	}
	public static void test(double a,double b){
		System.out.println(a+','+b);
	}
}

形参与实参

形参与实参的概念

  1. 形参：函数体中需要使用到的参数，目的用于接收调用该函数时传入的参数。

  2. 实参：实际的参数，就是调用方法传递的参数。

可变参数

一个方法中只能定义一个可变参数，它必须是方法的最后一个参数。任何普通参数都必须在它之前声明。

public class Demo{
	public static void main(String[] args){
		Demo demo = new Demo();
		int sum = demo.test(1,2,3);
		System.out.println(sum);
	}
	public static int test(int... numbers){
		int sum = 0;
		for(int i = 0; i < numbers.length; i++){
			sum += numbers[i];
		}
		return sum;
	}
}

递归方法

简单来说就是自己调用自己。

递归结构包含两个部分：

  • 递归头：什么时候不调用自身方法。如果没有递归头将会陷入死循环。

  • 递归体：什么时候调用自身方法。

一定要注意栈溢出带来的问题

public class Main{
	public static void main(String[] args){
		test();  //=> error,栈溢出
	}
	public static void test(){
		test();
	}
}

使用递归处理阶乘问题：

// 5! 5*4*3*2*1
public class Main{
	public static void main(String[] args){
		int a = test(5);
		System.out.print(a);
	}
	public static int test(int i){
		if(i==1){
			return 1;
		}else{
			return i * test(i-1);
		}
	}
}

值传递与引用传递

什么是值传递、引用传递

  1. 值传递：调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改将不会影响实际的参数。
public class Demo{
	public static void main(String[] args){
		int a = 1;
		Demo.changeA(a);
		System.out.print("print in main ->",a);
	}
	public static void changeA(int a){
		a = 10;
		System.out.println("print in changeA ->",a);
	}
}

----> 输出结果：
print in changeA ->10
print in main ->1
  1. 引用传递：调用函数时将实际参数的地址直接传递到函数中，这样函数中如果对参数进行修改将会影响实际的参数。
public class Demo{
	public static void main(String[] args){
		Demo2 demo2 = new Demo2();
		demo2.setName("hello");
		Demo.changeObj(demo2);
		System.out.println("print in main ->",demo2);
	}
	public static void changeObj(Object obj){
		obj.setName("world")
		System.out.println("print in changeObj ->",obj);
	}
}
public class Demo2{
	private String name;  // 封装一个私有属性
	public String getName(){
		return this.name;
	}
	public void setName(String name){
		this.name = name;
	}
}

----> 输出结果：
print in changeObj ->{name='world'}
print in main ->{name='world'}

经过上述的方法执行后，实参的值竟然被改变了，那按照上面的引用传递的定义，实际参数的值被改变了，这不就是引用传递了么。于是，根据上面的两段代码，得出一个新的结论：

Java的方法中，在传递普通类型的时候是值传递，在传递对象类型的时候是引用传递。但是，这种表述仍然是错误的。

public class Demo{
	public static void main(String[] args){
		String name = "hello";
		changeString(name);
		System.out.println("print in main ->",name);
	}
	public static void changeString(String name){
		name = "world";
		System.out.println("print in changeString ->",name);
	}
}

----> 输出结果：
print in changeObj ->world
print in main ->hello

在java 到底是值传递还是引用传递？

  • 错误理解一：值传递和引用传递区分条件是传递的内容，如果传递的是基本数据类型的值就是值传递，如果传递的是引用数据类型的值就是引用传递。

  • 错误理解二：java 就是引用传递。

答案只能是值传递！！

实际上在证明java 到底是值传递还是引用传递的过程中，验证方法就已经出错了，当然得到的结果就是错的。

为什么说是实验结果出错呢？本质上还是得从值传递和引用传递的根本区别入手：

值传递引用传递
根本区别会创建副本（复制一份）不会创建副本
执行效果函数中 无法改变原始参数函数中 可以改变原始参数

那么最终如何验证java 是值传递的？

public class Demo{
	public static void main(String[] args){
		Demo2 demo2 = new Demo2();
		demo2.setName("hello");
		changeObj(demo2);
		System.out.println("print in main ->",demo2);
	}
	public static void changeObj(Demo2 obj){
		obj = new Demo2();
		obj.setName("world");
		System.out.println("print in changeObj ->",obj);	
	}
}
public class Demo2{
	private String name;  // 封装一个私有属性
	public String getName(){
		return this.name;
	}
	public void setName(String name){
		this.name = name;
	}
}

----> 输出结果：
print in changeObj ->{name='world'}
print in main ->{name='hello'}

结论

  • java中方法参数传递方式是按值传递。

  • 如果参数是基本类型，传递的是基本类型的字面量值的拷贝。

  • 如果参数是引用类型，传递的是该参量所引用的对象在堆中地址值的拷贝。

main 方法

main 方法描述

public class Demo{
	public static void main(String[] args){
	
	}
}

【public】 ：main 方法是启动时候由JVM 进行加载的，public 的可访问权最高，所以必须使用public 修饰

【static】：调用方法的方式可以是对象调用、类调用，而main 方法因为是JVM 调用所以无需生成对象，所以使用static 修饰

【void】：调用main 方法无返回值，所以使用void修饰

【main】：C语言规定使用main 作为方法名

【String[]】：此字符串数组用来运行时接受用户输入的数据；因为字符串在JAVA 中具有普遍性，所以使用字符串是最优选择；数组的话因为参数不只一个，所以使用String[] 作为参数

不过在JDK 1.5 引入动态参数后String[] args也可以使用String… args 来实现。

public class Demo{
	public static void main(String... args){

	}
}

main 方法的重载

public class Demo {
    public static void main(String args) {
        System.out.println("main");
    }

    public static void main(String[] args) {
        main("test");
    }
}

main 被其他方法调用

public class Demo {
    public static int count = 3;

    public static void main2(String[] args) {
        count--;
        main(args);
    }

    public static void main(String[] args) {
        System.out.println("main 方法执行次数：" + count);
        if (count <= 0) System.exit(0);
        main2(args);
    }
}

输出结果：

main 方法执行次数：3
main 方法执行次数：2
main 方法执行次数：1
main 方法执行次数：0

main 方法被子类继承重写

public class Demo {
    public static void main(String[] args) {
        System.out.println("父类main 方法");
    }
}

class Demo2 extends Demo{
    public static void main(String[] args) {
        System.out.println("子类main 方法");
    }
}

输出结果：

子类main 方法

this 指向

this 指向类的实例对象

  • this 修饰属性，this.[属性名] 给实例中的属性赋值。
  • this 修饰方法，this.[方法名] 调用实例对象中的方法。
  • this 修饰构造器，在构造器中直接调用 this([参数]) 传递到同名重载构造器中，且this修饰构造器必须放在第一行。
public class Main{
    public Main(){
        
    }
    // 有参构造器
    public Main(String name,int age){
        this(age);
        this.name = name;
    }
    public Main(int age){
       this.age = age;
    }
    public static void main(String[] args){
        Main m = new Main("haha",20);
        m.say('hello,world')
    }
    // 属性
    int age;
    String name;
    String word;
    public void say(String word){
        // this执行实例化本身
        this.word = word;
        System.out.println(this.name);
        System.out.println(this.age);
        System.out.println("他说：" + this.word)
    }
}

静态代码块

https://blog.csdn.net/qq_35868412/article/details/89360250

java 中的四种代码块

  1. 方法块：静态方法、非静态方法、构造方法

  2. 非静态代码块：非静态代码块会 在创建对象时被调用，每次创建时都会被调用，优先于构造方法执行。

  3. 静态代码块：与类一并加载，用static{}包裹起来的代码片段，只会执行一次。静态代码块优先于非静态代码块执行。

  4. 同步代码块：使用synchronized(){}包裹起来的代码块，在多线程环境下，对共享数据的读写操作是需要互斥进行的，否则会导致数据的不一致性。

静态代码块与非静态代码块的异同点

相同点：都是jvm 加载类之后构造函数执行之前执行，在类中可以定义多个，一般代码块中对一些static 变量进行赋值操作。注意是赋值操作，避免空指针异常

package com.example.demo;

import java.util.HashMap;

public class test2 {
    private static HashMap<Integer,String> hashMap = null;
    static {
        hashMap.put(1,"2");  // 对一个指针进行操作，语法错误
    }
    public static void main(String[] args) {
        System.out.println(hashMap);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wtCtVK3j-1653532590899)(imgclip.png “imgclip.png”)]

正确操作：

package com.example.demo;

import java.util.HashMap;

public class test2 {
    private static HashMap<Integer,String> hashMap = null;
    static {
        hashMap = new HashMap<>();  // 先赋值再操作
        hashMap.put(1,"2");
    }
    public static void main(String[] args) {
        System.out.println(hashMap);
    }
}

不同点：静态代码块优先执行于非静态代码块，静态代码块只在第一次实例化对象执行一次，之后不再执行。而非静态代码块每实例化一次执行一次。

面试题

请问输出情况：

public class Demo {
    public static String name = "静态属性";

    static {
        System.out.println(name);
        System.out.println("静态代码块");
    }

    {
        System.out.println("非静态代码块1");
    }

    public Demo() {
        System.out.println("无参构造器");
    }

    {
        System.out.println("非静态代码块2");
    }

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

    public static void main(String[] args) {
        Demo demo = new Demo();
        System.out.println("main 静态方法块");
        Demo demo2 = new Demo();
        demo2.fn1();
    }
}

---> 输出结果
静态属性
静态代码块
非静态代码块1
非静态代码块2
无参构造器
main 静态方法块
非静态代码块1
非静态代码块2
无参构造器
非静态方法

出现继承情况：

class Demo2 {
    public static String name = "静态属性";

    static {
        System.out.println("子类静态属性" + Demo1.name);
        System.out.println("Demo2 静态代码块");
    }

    {
        System.out.println("Demo2 非静态代码块1");
    }

    public Demo2() {
        System.out.println("Demo2 无参构造器");
    }

    {
        System.out.println("Demo2 非静态代码块2");
    }
}

class Demo1 extends Demo2 {
    public static String name = "静态属性";

    static {
        System.out.println(name);
        System.out.println("父类静态属性" + Demo2.name);
        System.out.println("静态代码块");
    }

    {
        System.out.println("非静态代码块1");
    }

    public Demo1() {
        // super();
        System.out.println("无参构造器");
    }

    {
        System.out.println("非静态代码块2");
    }

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

public class Demo {
    public static void main(String[] args) {
        Demo1 demo = new Demo1();
        System.out.println("main 静态方法块");
        Demo1 demo1 = new Demo1();
        demo1.fn1();
    }
}

---> 输出结果
子类静态属性null
Demo2 静态代码块
静态属性
父类静态属性静态属性
静态代码块
Demo2 非静态代码块1
Demo2 非静态代码块2
非静态代码块1
非静态代码块2
无参构造器
main 静态方法块
Demo2 非静态代码块1
Demo2 非静态代码块2
非静态代码块1
非静态代码块2
无参构造器
非静态方法

结论

父静态属性 -> 父静态代码块 -> 子静态属性 -> 子静态代码块 -> 子静态方法main -> 父非静态代码块 -> 父构造方法 -> 子非静态代码块 -> 子构造方法 -> 非静态方法

全干丶
关注
02 JavaSE-- method、Object、初始代码块、constructor、this、super、final、static
m0_46671240的博客
05-04 143
02 JavaSE-- method、Object、初始代码块、constructor、this、super、final、static
JavaSE-No.6.3——代码块与内部类
Gujiu的博客
05-13 261
详细介绍代码块与内部类，一起来学习吧~
【09】JAVASE-面向对象-关键字【从零开始学JAVA】
波波烤鸭的博客
04-28 963
从零开始学Java系列课程
JavaSE--------基础语法（一）
疯纸的博客
12-20 632
一.基础语法1、基本数据类型（1）整数型 ①byte（字节型）：8位，取值范围是：-128~127，默认值是：0 ②short（短整型）：16位，取值范围是：-32768~32767，默认值是：0 ③int（整型）：32位，取值范围是：-2147483648 ~ 2147483647，默认值是：0 ④long（长整型）：64位，取值范围是：-9,223,372
javaSE-----继承和多态
2302_79862386的博客
03-08 3479
Java中使用类对现实世界中实体来进行描述，类经过实例化之后的产物对象，则可以用来表示现实中的实体，但是现实世界错综复杂，事物之间可能会存在一些关联，那在设计程序是就需要考虑。👌👌👌那具体来说是怎么样的呢？🧐🧐🧐举个例子，比如猫狗，他们都是一个动物：class Cat{System.out.println(this.name+"正在吃！");class Dog{System.out.println(this.name+"正在吃！");
JavaSE-类和对象详解
2301_80873677的博客
08-04 710
1.在IDEA中先新建一个包右键src ->新建->包2.在弹出的对话框中输入包名3.在包中创建类右键包名->新建->类然后输入类名即可如图：此时可以看到我们的磁盘上的目录结构已经被IDEA自动创建出来了在文件的最上方加上一个package语句指定该代码在哪个包中如果一个类没有package语句则该类被放到一个默认包中。
（1）JavaSE---类和对象、this、static
qq_44329028的博客
02-08 593
1. 类和对象 1.1 基本概念 类是指共性的概念，而对象指的是一个具体的、可以使⽤用的事物。 首先产生类（类是⽣生产对象的蓝图），而后才可以产⽣生对象。 对象的所有行行为，一定在类中进行了完整的定义。 1.2 类中的组成 属性（变量，描述每个对象的具体特点） 方法（操作的⾏行行为） 1.3 定义和使用 定义： class 类名称 { 属性1； ... 方法1（） {} ... } 范例例： Person类的定义 class Person{ public String name; p
javaSE-类与对象-构造器-this关键字-static关键字
mizui_i的博客
11-22 278
目录 一.面向对象 1.1概述 1.2面向过程和面向对象 1.3类和对象的区别 1.4实例化过程/创建对象的过程 1.5 对象的使用和特征 1.6常见异常 1.7 javaBean 二.构造方法 2.1概述 2.2构造方法和普通方法 三.this关键字 四.static 1.静态变量 2.静态方法 3.静态语句块 4.实例语句块 5.类加载 6.静态和成员 一.面向对象 1.1概述 面向对象(Object Oriented)是一种思想,将数据和方法作为整体来看待,
JavaSE-02笔记【封装~this和static】
weixin_45041745的博客
02-13 731
this不能出现在static的方法中，可以出现在实例方法中，代表当前对象。多数情况下this是可以省略不写的，但是在区分局部变量和实例变量的时候不能省略。在实例方法中可以直接访问当前对象实例变量以及实例方法，在static方法中无法直接访问实例变量和实例方法。static 是 java 语言中的关键字，表示“静态的”，它可以用来修饰变量、方法、代码块等，修饰的变量叫做静态变量，修饰的方法叫做静态方法，修饰的代码块叫做静态代码块。
【0基础学java】教学日志：javaSE-面向对象3-this关键字、static关键字、代码块、package、import、封装、访问修饰符
jason的java世界
01-08 1716
【0基础学java】教学日志：javaSE-面向对象3本章概述一、this关键字二、static关键字三、代码块四、package五、import六、封装七、面向对象的三大特征八、使用访问控制符，实现封装(下次课讲)九、总结(下次课讲)十、作业(下次课讲)1、上机练习1——设计Dog和Penguin类2、上机练习2——打印Dog信息2-13、上机练习3——Dog类的带参构造方法4、上机练习4——操作企鹅性别属性 本章概述 本章属于面向对象第二章的内容，主要讲解this关键字、static关键字、代码块、p
JavaSE_代码块
proficient2018的博客
04-23 907
代码块的定义 有若干条Java语句组成，并且用一对大括号括起来的结构，叫做代码块。 代码块当中定义的变量是局部变量，被代码块的大括号限制作用域。 注意类体不算做代码块。   代码块的分类 根据其位置和声明方式不同，可以分为 局部代码块：声明定义在局部位置的代码块。 构造代码块：声明定义在类的成员位置的代码块。 静态代码块：声明定义在类的成员位置的代码块，但是用static修饰。 同步代码块：是多线程中用于同步的一种代码块结构，涉及多线程知识。   局部代码块 语法 定义在局部位置，使
JavaSe-学习知识点汇总
a931394057的博客
11-09 2116
个人认为比较重要的JvaSe知识点汇总
JavaSE---面向对象
qq_44125413的博客
01-22 670
面向过程和面向对象 面向过程：procedure oriented programming 缩写 POP 分析出解决问题所需要的步骤，然后把步骤一步一步实现。 面向过程直接关注流程。 面向对象：object oriented programming 缩写 OOP 面向对象的编程语言以分类的方式进行思考和解决问题。 面向对象先对整体关系作出分类，然后根据不同的类深入细节的处理。 面向对象的思想符合人类的认知习惯。 JAVA类 什么是类？ 类是一个模板，它是描述一类事物(具体的对象，具体的存在)的属性和行为
JavaSE--第二阶段2
HK_Milky的博客
08-15 297
1、枚举和注解 1、枚举介绍 枚举类【枚: 一个一个 举： 例举 , 即把具体的对象一个一个例举出来的类就称为枚举类】 2、自定义类实现枚举 不需要提供setXxx方法，因为枚举对象值通常为只读 对枚举对象 / 属性使用final+static共同修饰，实现底层优化 枚举对象名通常使用全部大写 枚举对象根据需要，也可以有多个属性 构造器私有化 本类内部创建一组对象 对外暴露对象（通常为对象添加public final static ） 可以提供get方法，不不提供set方法
JAVA-01-变量
LJH_laura_li的博客
11-08 419
在方法、构造函数或块内部定义的变量。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 261
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
基于 SpringBoot 实现QQ邮箱验证码注册功能
2301_79201049的博客
11-06 655
找到并开通以下的邮件协议服务，而且服务开启也较为简单，需要我们发送一个短信到指定的号码，开启后平台会提供一个授权码，一定要记住这个授权码，发邮件的时候需要这个。host 是根据服务主机区分，网易邮箱是 smtp.163.com, qq邮箱是 smtp.qq.com。其中的 username 是你第一步中操作的邮箱账号，nickname 是接收者收到邮件中显示的发件人。发送邮件的核心依赖是 mail ，由于该项目还涉及其他依赖就全都导进来了。（1）首先打开QQ邮箱，点击设置并来到账号页面。
Java基于小程序公考学习平台的设计与实现（附源码，文档）
最新发布
chusheng1840的博客
11-09 1005
Java基于小程序公考学习平台的设计与实现，小程序公考学习平台使用Java语言进行编码，使用Mysql创建数据表保存本系统产生的数据。系统可以提供信息显示和相应服务，其管理小程序公考学习平台信息，查看小程序公考学习平台信息，管理小程序公考学习平台。总之，小程序公考学习平台集中管理信息，有着保密性强，效率高，存储空间大，成本低等诸多优点。它可以降低信息管理成本，实现信息管理计算机化。关键词：小程序公考学习平台；Java语言；Mysql。
java_方法重写/覆盖(override)
HHppGo的博客
11-07 335
方法覆盖（重写）就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的方法。
那javaSE -17可不可以用
06-12
JavaSE-17是Java的最新版本，如果您使用JavaSE-17，则可以使用Java 14中引入的记录（Record）特性而无需担心保留字问题。JavaSE-17中包含了Java 14及更早版本中的所有功能，同时还引入了新的功能和改进。 因此，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值