# Java基础知识

最新推荐文章于 2023-12-19 13:21:28 发布
最新推荐文章于 2023-12-19 13:21:28 发布
阅读量912 收藏 2
点赞数
文章标签： java 开发语言 后端 javase
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JF_98/article/details/122041692
版权

1.两个对象在内存图

在这里插入图片描述

2.private

一旦使用private进行修饰，那么在本类中任然可以随意访问，但是，超出了本类范围之外就不能直接访问了。
在这里插入图片描述
在这里插入图片描述
但是可以间接访问，就是定义一对Getter/Setter方法。
在这里插入图片描述

对于基本类型当中的Boolean值，Getter方法一定要写成isXxx的形式，Setter方法不变。

3.this

  • ​ 当方法的局部变量和成员变量重名的时候，根据’就近原则‘，优先使用局部变量。

  • ​ 如果需要访问本类当中的成员变量，需要使用格式：

  • ​ this.成员变量名

  • ​ “通过谁调用的方法，谁就是this”
    在这里插入图片描述

4.构造方法

构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法。格式:

​ public 类名称(参数类型 参数名称){

​ 方法体

​ }

注意事项：

  1. 构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样

  2. 构造方法不要写返回值类型,连void都不写

  3. 构造方法不能return—个具体的返回值

  4. 如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数、方法体什么事情都不做。

public  Student() { }

  1. —旦编写了至少一个构造方法，那么编译器将不再赠送。

  2. 构造方法也是可以重载的

重载：方法名称相同，参数列表不同

5.标准的类

一个标准的类通常要拥有下面四个组成部分:

  1. 所有的成员变量都要使用private关键字修饰

  2. 为每一个成员变量编写一对儿Getter/Setter方法

  3. 编写一个无参数的构造方法

  4. 编写一个全参数的构造方法这样标准的类也叫做Java Bean

6.Scanner

  1. 导包

    import java.util.Scanner;

  2. 创建

    //备注：System.in代表从键盘进行输入
Scanner sc = new Scanner(System.in);

  3. 使用

    //获取键盘输入的一个int数字:int num = sc.nextInt( );

//获取键盘输入的一个字符串:String str = sc.next( );

7.匿名对象

  • ​ 匿名对象就是只有右边的对象，没有左边的名字和赋值运算符。格式：

  • ​ new 类名称();

  • ​ 注意事项：匿名对象只能使用唯一的一次，下次再用不得不再创建一个新对象。

  • ​ 使用建议：如果确定有一个对象只需要使用唯一的一次，就可以用匿名对象。

8.Random

Random类用来生成随机数字。使用起来也是三个步骤;

  1. 导包

    import java.util.Random;

  2. 创建

    Random r = new Random(); //小括号当中留空即可

  3. 使用

    获取一个随机的int数字（范围是int所有范围，有正负两种）:

     int num = r.nextInt()

    获取一个随机的int数字（参数代表了范围，左闭右开区间):

     int num = r.nextInt(3)

    实际上代表的含义是:[0,3)，也就是0~2

9.ArrayList集合

1.概念

  • ​ 数组的长度不可以发生改变。

  • ​ 但是ArrayList集合的长度是可以随意变化的。

  • ​ 对于ArrayList来说，有一个尖括号代表泛型。

  • ​ 泛型：也就是装在集合当中的所有元素，全都是统一的什么类型。

  • ​ 注意：泛型只能是引用类型，不能是基本类型。

//创建了一个ArrayList集合，集合的名称是List，里面装的全都是string字符串类型的数据
//备注:从JDK 1.7+开始，右侧的尖括号内部可以不写内容，但是<>本身还是要写的。
ArrayList<String> list = new ArrayList<>();

​ 注意事项:

​ 对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。如果内容是空，得到的是空的中括号：[ ]

2.常用的方法
public boolean add(E e);//向集合当中添加元素，参数的类型和泛型一致。返回值代表添加成功
//备注:对于ArrayList集合来说，add添加动作一定是成功的，所以返回值可用可不用。
//但是对于其他集合(今后学习)来说，add添加动作不一定成功。

public E get(int index);//从集合当中获取元素，参数是索引编号，返回值就是对应位置的元素。

public E remove(int index);//从集合当中删除元素，参数是索引编号，返回值就是被珊除掉的元素。

public int size();//获取集合的尺寸长度，返回值是集合中包含的元素个数。

泛型只能是引用类型，不能是基本类型，如果希望向集合ArrayList当中存储基本类型数据，必须使用基本类型对应的“包装类

基本类型 包装类（引用类型，包装类都位于java.Lang包下)

byte Byte

short Short

int Integer 【特殊】

long Long

float Float

double Double

char Charactor 【特殊】

boolean Boolean

10.字符串

  • ​ java.Lang.String类代表字符串。

  • ​ API当中说：Java程序中的所有字符串字面值（如“abc”）都作为此类的实例实现。

  • ​ 其实就是说：程序当中所有的双引号字符串，都是string类的对象。(就算没有new，也照样是。)

1.字符串的特点：
1. 字符串的内容永不可变。【重点】
2. 正是因为字符串不可改变，所以字符串是可以共享使用的。
3. 字符串效果上相当于是char[ ]字符数组，但是底层原理是byte[ ]字节数组。
2.创建字符串的常见3+1种方式。

三种构造方法：

  1. public String():创建一个空白字符串，不含有任何内容。
  2. public String(char[ ] array):根据字符数组的内容，来创建对应的字符串。
  3. public String(byte[ ] array):根据字节数组的内容，来创建对应的字符串。

—种直接创建：

​ String str = “HeLLo”;

3.字符串常量池

字符串常量池：程序当中直接写上的双引号字符串，就在字符串常量池中。

​ 对于基本类型来说，==是进行数值的比较。

​ 对于引用类型来说，==是进行地址值的比较。

4.字符串常量池内存图

在这里插入图片描述

5.字符串常用的方法
1.比较值的方法
==是进行对象的地址值比较，如果确实需要字符串的内容比较，可以使用两个方法;
public boolean equals(0bject obj)：参数可以是任何对象，只有参数是一个字符串并且内容相同的才会给true，否则返回false。
public boolean equalsIgnoreCase(String str)：忽略大小写，进行内容比较。

​ 注意事项：

  1. 任何对象都能用object进行接收。

  2. equals方法具有对称性，也就是a.equals(b)和b.equals(a)效果一样。

  3. 如果比较双方一个常量一个变量，推荐把常量字符串写在前面。

    推荐：“abc”.equals(str) 不推荐：str.equals( “abc”)

2.与获取的方法
public int Length()：获取字符串当中含有的字符个数，拿到字符串长度。
public String concat(String str)：将当前字符串和参数字符串拼接成为返回值新的字符串。
public char charAt(int index)：获取指定索引位置的单个字符。(索引从e开始。)
public int indexOf(String str)：查找参数字符串在本字符串当中首次出现的索引位置，如果没有返回-z值。
3.与截取的方法
public String substring(int index)：截取从参数位置一直到字符串末尾，返回新字符串。
public String substring(int begin，int end)：截取从begin开始，一直到end结束，中间的字符串。
备注：[ begin , end)，包含左边，不包含右边。
4.与转换有关的方法
public char[ ] toCharArray()：将当前字符串拆分成为字符数组作为返回值。
public byte[] getBytes()：获得当前字符串底层的字节数组。
public String replace(CharSequence oldstring,CharSequence newString)：将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串。
备注：CharSequence意思就是说可以接受字符串类型。
5.与分隔有关的方法
public String[ ] split(String regex):按照参数的规则，将字符串切分成为若干部分。
注意事项：
split方法的参数其实是一个“正则表达式”，今后学习。
今天要注意:如果按照英文句点“.”进行切分，必须写"\\." (两个反斜杠)

11.静态static关键字

在这里插入图片描述

1.static修饰成员变量

​ 如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类。多个对象共享同一份数据。

2.static修饰成员方法
  • 一旦使用static修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是属于类的。
  • 如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。
  • 如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。
  • 无论是成员变量，还是成员方法。如果有了static，都推荐使用类名称进行调用。
  • 静态变量：类名称.静态变量
  • 静态方法：类名称.静态方法()

注意事项：

  1. 静态不能直接访问非静态。

​ 原因：因为在内存当中是先有的静态内容，后有的非静态内容。

​ “先人不知道后人，但是后人知道先人。”

  1. 静态方法当中不能用this。

​ 原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。静态方法调用的是类，不是对象。

3.static关键字的内存图

在这里插入图片描述

4.静态代码块

​ 静态代码块的格式是：

public class类名称{
    static{
        //静态代码块的内容
    }
}

特点:当第一次用到本类时，静态代码块执行唯一的一次。

静态内容总是优先于非静态，所以静态代码块比构造方法先执行。

静态代码块的典型用途：

​ 用来一次性地对静态成员变量进行赋值。

12.数组工具类Arrays

java.util.Arrays是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作。

//public static String toString(数组):将参数数组变成字符串（按照默认格式:[元素1，元素2，元素3...])
public static void main(String[] args){
    int[] intArrays = {10, 20, 30};
    //将int[]数组按照默认格式变成字符串
    String intStr = Arrays.toString(intArrays);
    System.out.println(intStr);//[10, 20, 30]
}

//public static void sort(数组)：按照默认升序（从小到大）对数组的元素进行排序
/*
备注:
1. 如果是数值,sort默认按照升序从小到大
2. 如果是字符串， sort默认按照字母升序
3．如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持。(今后学习)
*/
public static void main(String[] args) {
    int[] array1 = {2, 1, 3, 10, 6};
    Arrays.sort(array1);
    System.out.println(Arrays.toString(array1));//[1, 2, 3, 6, 10]
}

13.数学工具类Math

/*
java.util.Math类是数学相关的工具类，里面提供了大量的静态方法，完成与数学运算相关的操作。

public static double abs (double num):获取绝对值。有多种重载。
public static double ceil ( double num):向上取整。
public static double floor( double num):向下取整。
public static long round ( double num):四舍五入。

Math.PI 代表近似圆周率
*/
    public static void main(String[] args) {
        //获取绝对值
        System.out.println(Math.abs(3.15));//3.15
        System.out.println(Math.abs(0));//0
        System.out.println(Math.abs(-2.5));//2.5

        //向上取整
        System.out.println(Math.ceil(3.9));//4.0
        System.out.println(Math.ceil(3.1));//4.0
        System.out.println(Math.ceil(3.0));//3.0

        //向下取整。
        System.out.println(Math.floor(3.9));//3.0
        System.out.println(Math.floor(3.9));//3.0
        System.out.println(Math.floor(3.0));//3.0
        
        //四舍五入。
        System.out.println(Math.round(4.5));//5
        System.out.println(Math.round(4.3));//4
        System.out.println(Math.round(4.0));//4
    }

14.继承

1.重写和重载
  • 重写(Override)：方法的名称一样，参数列表也—样。
  • 重载(Overload)：方法的名称一样，参数列表不一样。
2.supper关键字
/*
super关键字的用法有三种:
1．在子类的成员方法中，访间父类的成员变量。
2．在子类的成员方法中，访问父类的戒员方法。
3．在子类的构造方法中，访问父类的构造方法。
*/

//子类
public class Zi extends Fu{
    int num = 20;
    
    public Zi() {
    	super();
    }
    
    public void methodZi(){
        System.out.println(super.num); //父类中的num
    }
    
    public void method(){
        super.method();//访问父类中的method
        System.out.println("子类方法");
    }
}

//父类
public class Fu(){
    int num = 10;
    public void method(){
        System.out.println("父类方法");
    }
}
3.this关键字
/*
super关键字用来访问父类内容，而this关键字用来访间本类内容。用法也有三种:

1. 在本类的成员方法中，访问本类的成员变量。
2. 在本类的成员方法中，访问本类的另一个成员方法。
3．在本类的构造方法中,访问本类的另一个构造方法。
在第三种用法当中要注意:
A. this( ...)调用也必须是构造方法的第一个语句，唯—一个。
B. super和this两种构造调用,不能同时使用。
*/

在这里插入图片描述

4.继承的三个特点
  1. Java语言是单继承的。一个类的直接父类只能有唯一一个。
  2. Java语言可以多级继承。我有一个父亲，我父亲还有一个父亲，也就是爷爷。
  3. 一个子类的直接父类是唯一的，但是一个父类可以拥有很多个子类。可以有很多个兄弟姐妹，生二胎。

15.抽象

1.抽象方法和抽象类
/*
抽象方法:就是加上abstract关键字，然后去掉大括号，直接分号结束。
抽象类:抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可。
*/
//抽象类
public abstract class Animal(){
    //这是抽象方法
    //public abstract 返回值类型 抽象方法名();
    public abstract void eat();
    
    //这是一个普通方法
    //public void normalMethod(){
    //}
}

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

public class Demo(){
    public static void main(String[] args){
        Cat cat = new Cat();
        cat.eat();
    }
}
2.如何使用抽象类和抽象方法

  1. 不能直接创建new抽象类对象。

  2. 必须用一个子类来继承抽象父类。

  3. 子类必须覆盖重写抽象父类当中所有的抽象方法。

    覆盖重写(实现):子类去掉抽象方法的abstract关键字，然后补上方法体大括号。

  4. 创建子类对象进行使用。

3.注意事项

  1. 抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。

    理解:假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。

  2. 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

    理解:子类的构造方法中，有默认的super()，需要访问父类构造方法。

  3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

    理解:未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。

  4. 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。

    理解:假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。

16.接口

1.接口的概念
接口就是多个类的公共规范。
接口是—种引用数据类型，最重要的内容就是其中的:抽象方法。如何定义一个接口的格式:
public interface接口名称{
//接口内容
}
备注:换成了关键字interface之后，编译生成的字节码文件仍然是: .java --> .class。
知果是Java 7，那么接口中可以包含的内容有:
1．常量
2．抽象方法
如果是Java 8，还可以额外包含有:
3．默认方法
4．静态方法
如果是Java 9，还可以额外包含有:
5．私有方法

注意事项：
1．接口当中的抽象方法，修饰符必须是两个固定的关键字: public abstract
2．这两个关键字修饰符，可以选择性地省略。(今天刚学，所以不推荐。)

17.多态

1.概念
extends继承或者implements实现，是多态性的前提。

小明是一个对象。
这个对象既有学生形态，也有人类形态。一个对象拥有多种形态，这就是:
对象的多态性
2.多态的格式和使用
代码当中体现多态性，其实就是一句话:父类引用指向子类对象。格式:
交类名称 对象名= new 子类名称();
或者:
接口名称 对象名= new 实现类名称();

public static void main(String[] args){
	//使用多态的写法
	//左侧父类的引用，指向了右侧子类的对象
	Fu obj = new Zi();
	
	obj.method();//输出“子类方法”
	obj.methodFu();//输出“父类特有方法”
}

public class Fu{
	public void method(){
		System.out.println("父类方法");
	}
	public void method2(){
		System.out.println("父类特有方法");
	}
}

public class Zi extends Fu{
	public void method(){
		System.out.println("子类方法");
	}
}
3.多态中的成员变量使用
访间成员变量的两种方式:
1．直接通过对象名称访问成员变量:看等号左边是谁，优先用谁，没有则向上找。
2．间接通过成员方法访问成员变量:看该方法属于谁，优先用谁，没有则向上找。
public static void main(String[] args) {
	//使用多态的写法,父类引用指向子类对象
    Fu obj = new Zi();
    System.out.println(obj.num); //父:14
      //System.out.printLn(obj.age); //错误写法!
    system.out.println( "=============");
    //子类没有覆盖重写，就是父:10
    //子类如果覆盖重写，就是子:20
    obj.showNum(); 
}

public class Fu {
    int num = 10;
    
    public void showNum(){
        System.out.println(num);
    }
}

public class zi extends Fu {
    int num = 20;
    int age = 16;

    @Override
    public void showNum(){
        System.out.println(num);
    }
}
4.多态中的成员方法的使用
在多态的代码当中，成员方法的访问规则是:
	看new的是谁,就优先用谁，没有则向上找。
        
口诀:编译看左边,运行看右边。
    
对比一下：
    成员变量：编译看左边，运行还看左边。
    成员方法：编译看左边，运行看右边。
public class Demo02MultiMethod {
    public static void main(String[]args) {
        Fu obj = new Zi();//多态
        obj.method(); //父子都有，优先用子
        obj.methodFu();//子类没有，父类有,向上找到父类
        
        //编译看左边,左边是Fu，Fu当中没有methodzi方法，所以编译报错。
        obj.methodZi();//错误写法!
}
5.多态的好处

在这里插入图片描述

6.对象的向上转型

在这里插入图片描述
在这里插入图片描述

7.instanceof

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

18.final关键字

1.概念
finaL关键字代表最终、不可改变的。

常见四种用法:
1．可以用来修饰一个类
2．可以用来修饰一个方法
3．还可以用来修饰一个局部变量
4.还可以用来修饰一个成员变量
2.用法
1.当final关键字用来修饰一个类的时候。
格式:
public final class类名称{
	//...
}
含义：当前这个类不能有任何的子类。（太监类）
注意：一个类如果是final的,那么其中所有的成员方法都无法进行覆盖重写（因为没有儿子。）
    
2.当final关键字用来修饰一个方法的时候。
格式：
修饰符 final 返回值类型 方法名称(参数列表){
	//方法体
}
含义：这个方法就是最终方法，也就不能被覆盖重写。
注意事项：
对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。

3.当final关键字来修饰局部变量。
格式：
    final 数据类型 变量名;
含义：一次赋值，终生不变。
注意：1.对于基本类型来说,不可变说的是变量当中的数据不可改变
2.对子引用类型来说,不可变说的是变量当中的地址值不可改变，--值可以改变--
    
4. 当final关键字用来修饰成员变量

含义：1.这个变量照样不可变，由于成员变量具有默认值，所以用了final之后必须手动赋值。
2.对呀final的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一。
3.必须保证类当中所以重载的构造方法，都最终会对final的成员变量进行赋值。
    private final String name = "方浴荷";

19.权限修饰符

java中有四种权限修饰符
​		  	              public 	> 	protected 	>	 (default)  >  	private
同一个类	           yes			  yes				   yes				yes
同一个包		       yes			  yes			       yes				no
不同包子类	       yes		      yes				   no				    no
不同包非子类	   yes			  yes				   no				    no

注意事项：(default)并不是关键字"default",而是根本不写
JF_98
关注
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
PTAjava选项题
weixin_56710260的博客
06-17 2187
在windows平台上安装配置JDK时，下列的说法错误的是_____。C.javac的功能是编译并执行 java代码项 一个计算机上安装JDK后，该计算机不包含的是（）。C.Eclipse 有一段java 应用程序，它的主类名是a1，那么保存它的源文件名可以是（ ）.A.a1.java Java语言具有许多优点和特点，哪个反映了Java程序并行机制的特点？( )B.多线性 编译Java源程序文件将产生相应的字节码文件，这些字节码文件的扩展名为( )。B..class 在Java中，负责对字节代码解释执
Java 成员变量与局部变量名重复
p10614040的专栏
08-17 3186
Java 中成员变量和局部变量可以重复定义。
浅析Java中局部变量与成员变量同名解决技巧
hhf365的博客
04-26 4499
成员变量和局部变量的区别 成员变量： ①成员变量定义在类中，在整个类中都可以被访问。 ②成员变量随着对象的建立而建立，随着对象的消失而消失，存在于对象所在的堆内存中。 ③成员变量有默认初始化值。 局部变量： ①局部变量只定义在局部范围内，如：函数内，语句内等，只在所属的区域有效。 ②局部变量存在于栈内存中，作用的范围...
Java PTA(5)——类与对象2
m0_61442114的博客
12-19 871
该类有一个playSound(Animal animal)方法，该方法的参数是Animal类型，即参数animal可以调用Animal的子类重写的cry()方法播放具体动物的声音，调用子类重写的getAnimalName()方法显式动物种类的名称。2.4 在Java中，一个类可同时定义许多同名的方法，这些方法的形式参数的个数、类型或顺序各不相同，传回的值也可以不相同，这种面向对象程序特性称为（ ）。2.6 在非静态成员方法中，可以使用关键字（ ）指代当前对象，访问类的其他非静态成员。
java基础知识复习
m0_75052101的博客
04-24 162
在面向对象的思想中最核心的就是对象，为了在程序中创建对象，首先需要定义一个类。类是对象的抽象，它用于描述一组对象的共同特征和行为。类中可以定义成员变量和成员方法，其中成员变量用于描述对象的特征，也被称作属性，成员方法用于描述对象的行为，可简称为方法。例题/** 描述人事物* 都是人的共性内容*///定义int类型变量age//定义speak()方法System.out.println("大家好，我今年" + age +"岁！");
zdp072#java-interview#Java基础知识1
07-25
Java有两种类型的异常:checked(检查)与unchecked(未检查)异常.checked异常必须通过方法或构造函数的throws子句显式声明.unch
Java基础知识总结
09-04
### Java基础知识总结 #### Java 入门概述 Java 作为一种广泛应用的编程语言，自1995年由 Sun Microsystems 发布以来，迅速成为了软件开发领域的主流技术之一。Java 的诞生不仅推动了软件行业的进步，还引领了一...
java教程基本-java基础知识一
最新发布
02-28
### Java基础知识概述 #### 1. Java简介 Java是由Sun Microsystems公司于1995年推出的面向对象的程序设计语言。最初由James Gosling及其团队研发，并在同年正式发布。随着时间的发展，Sun Microsystems被Oracle公司...
Java基础知识总结 （绝对经典）
11-06
### Java基础知识总结（绝对经典） #### 一、Java概述 - **起源与发展**：Java语言始于1991年Sun公司的James Gosling等人所开发的Oak语言，原计划用于控制嵌入式设备如有线电视交换盒和个人数字助理(PDA)。1994年...
Java——This 关键字：局部变量和成员变量重名时，在成员方法中使用成员变量的方法
树下等苹果的博客
03-14 3750
package Myfirst_package; //this 关键字:当局部变量和成员变量重名时，成员变量就会被隐藏，这是如果想在成员方法中使用成员变量，必须使用this 关键字 public class Fruit { public String color = "绿色"; public void harveat() { String color = "红色"; System.out.println("水果是"+color+"的"); System.out.println("水果已经收获
java 变量重名_关于java中变量的重名问题
weixin_36248959的博客
02-13 2564
在java语言中，变量的命名有很多规则和规范，但是有的地方可以使用相同的变量名，有的地方却不能使用，这是为什么呢？下面是个人的一点见解，是从作用域和内存来分析的，目的是为了方便理解大家可以看下面这段代码：public class Test01 {//static int a =1;//所有的对象都有这个，所有不能重名int a=5;//单个对象的属性，在堆中存储public static void...
成员变量，实例变量，静态变量，类变量
diangu7329的博客
06-11 127
成员变量（实例变量）&局部变量区别： (1)作用域成员变量：整个类内部可见局部变量：只在某个范围内有效。(一般指的就是方法,语句体内)(2)存储位置成员变量：随着对象的创建而存在，随着对象的消失而消失，存储在堆内存中。局部变量：在方法被调用，或者语句被执行的时候存在，存储在栈内存中，作用的范围结束，变量空间会自动释放。(3)初始值成员变量：无需显式初始化，系统会自动对其...
局部变量与全局变量同名时如何在局部变量的作用范围内访问全局变量？
weixin_42867975的博客
01-23 3684
怎么做：当局部变量与全局变量同名时在局部变量的作用域内，可以通过关键字this来引用成员变量。 特别注意：关键字this代表的是一个对象，只能用在非静态中，不能用在静态中，因为在静态中this可能是类名也可能是对象，因此在编译时会报错，如果需要，可以通过对象去访问成员变量 代码说明： public class Test { int x=1; static void show() { int x=2; System.out.println("局部变量："+x); //System.ou
成员变量和局部变量同名问题
weixin_41874888的博客
01-26 4793
通过前面学习，基本明确了对象初始化过程中的细节，也知道了构造方法之间的调用是通过this关键字完成的。但this也有另外一个用途。 当在方法中出现了局部变量和成员变量同名的时候，那么在方法中怎么区别局部变量成员变量呢？可以在成员变量名前面加上this.来区别成员变量和局部变量 class Person { private int age; private String na...
解答java中局部变量和本类成员变量和父类成员变量都重名了咋办
fighting_dream的博客
06-08 450
调用的时候呢： 局部变量： 直接写成员变量名 本类的成员变量： this.成员变量名 父类的成员变量: super.成员变量名 现在这里有一个父类，我定义了一个num，如下： package cn.itcast.day0608.demo05; public class Demo03FU { int num = 10; } 我再定义一个子类，继承父类，并且有它自己的成员变量，在定义一个成员方法，成员方法里面定义局部变量。再来输出： package cn.itcast.day0608.demo0
java中全局变量是否可以和局部变量重名？（一个菜鸟的积累）
qq_35383788的博客
01-22 6477
能。但是进行局部运算的时候，局部变量会屏蔽全局变量。 所以怎么区别使用局部变量和全局变量呢？ Example：   Class A {    int a = 1    public static void main(String[] args) { A c = new A();  a = 2; system.out.println(a); ..........println(
1.局部变量和成员变量同名时，怎么把局部变量赋值给成员变量？ 2.Java怎样将一个方法里面的局部变量赋值给另一个方法？
Veloma_tothepast的博客
03-29 716
this.[成员变量] = [局部变量];
成员变量和局部变量同名 / 局部变量的作用域最小化
heartbeaty的专栏
04-20 3925
成员变量和局部变量同名 在同一个作用域内不允许定义同名的多个变量。   在一个方法内，可以定义和成员变量同名的局部变量或参数，此时成员变量被屏蔽。此时如果想要访问成员变量，可以通过 this 关键字来访问，this 关键字来访问，this 为当前实例的引用，如果要访问类变量，可以通过类名来访问。     局部变量的作用域最小化   将局部变量的作用域最小化，可增加代码的可读
全面掌握Java基础知识要点
以上便是Java基础知识点的概述，对于初学者而言，理解和掌握这些知识点是学习Java的第一步。通过实践操作，不断编写代码和调试程序，可以逐渐加深对Java语言的理解和应用。同时，这些基础知识点也为后续深入学习Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值