[TOC]

class 和 数组 在内存上的相似性

类和数组的 名 ，均保存的是地址值

即 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static class myclass()
{
	int num;
	string str;
	
	public void change(int a ,string s)
	{
		a = a+1;
	}
}
...mian...()
{
    myclass class01 = new myclass();
    myclass class02 = class01;//这一步把class01的地址值赋值给了class02，他们两个现在指向同一片内存空间
}
成员变量和局部变量的区别

  • 初始化值不同：

    成员变量有初始值，局部变量没有

  • 内存位置不同：

    成员变量在堆中（本质是跟着对象走），局部变量在栈中（本质是跟着方法走）

  • 生命周期不同：

    成员变量跟着对象走，随着对象的产生而产生，随着对象的消亡而消亡

    局部变量跟着方法走，随着方法的调用而产生，随着方法结束而消亡

this关键字——>区分成员变量和局部变量
  • 局部变量和成员变量重名时，遵循“就近原则”
  • 如果就想用成员变量，那就用 this.变量名 来引用成员变量

对象之间如何区分？

  • 哪个对象调用的方法，this就指向哪个对象
引用数据类型，要先new

（什么是引用数据类型：除了基本数据类型，都是引用数据类型）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public static class MyData()
{
	int a;
	string s;
	static float c;
}

//========== 其他作用域=========

string a = "666";    //正常赋值
int c = string b.length; //报错，空指针，根本原因是没有初始化string类型具体是什么，而直接操作他的成员变量

//同理：

MyData mydata = new MyData();
mydata.a = 1;      //正常，先new了一个对象，然后操作他的成员变量

MyData mydata_error.a = 2; //空指针，因为连mydata_error对象都还没创建，就直接操作他的成员变量


//但是，static的变量可以直接通过 类名 访问，（不是对象名）

MyData.c = "我是静态变量"; //正常

javabean在业务处理中的作用

javabean与表的对应关系：

类名——>表名

各个实例化对象——>每一行

成员变量——>每一列的列头（也就是对应的参数）

  • 添加功能：

image-20250403200744494

  • 查询功能：
    image-20250403201600516

标准javabean生成快捷键：alt + insert

java中，static的用法

静态成员随着类的调用而产生，非静态成员随着对象的产生而产生

因此注意四种辨析：

  • 在静态成员中能直接访问非静态成员吗：

    不能，想在静态成员中访问非静态成员，要先new对象
    eg：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    public class Demo{
        public static void main(String[] args）{
            test01();   //——————>可行，静态调用静态
            test02();   //——————>不可行，静态不能直接调用非静态，因为静态成员比非静态先产生
            
            //===正确调用：========        
            Demo mydemo = new Demo();
            mydemo.test02();
            //====================
        }
        public static void test01(){
            sout("我是静态成员");
        }
        public void test02(){
            sout("我是非静态成员");
        }
    }

  • 在非静态方法中能直接访问静态成员吗：

    可以，同类下的话，直接调用即可，不同类的话，通过类名调用（也就是静态方法跟着类走，不跟着对象走）

    当然，也可以不管是不是同类，直接类名调用

  • 在静态方法中能直接调用静态成员吗：

    可以，同上

  • 在非静态方法中能直接调用非静态成员吗？

    可以，同类下可以直接调用，也可以new对象调用，不同类下需要new对象调用

    当然，也可以不管是否同类，都通过new对象调用

总结：

1.不管在不在同一个类中,非静态成员都可以new对象调用

2.不管在不在同一个类中,静态成员都可以类名调用

可变参数

可变参数本质上是一个数组,用于传递类型已知但数量未知的数据类型

形式：

数据类型…变量名，如 int…nums String…kids

还有，可变参数必须位于传参的最后面位置

对象数组

就是数组的元素是对象，类如

int数组：int[] arr_int = new int[3]

Person数组： Person arr_person = new Person[3]

一些操作

  • 先调用方法再生成：

    alt+回车

  • 将一段代码抽取到一个方法：

    ctrl+alt+m

有关继承：
子类可以继承什么

a.子类可以继承父类中私有和非私有成员,但是不能使用父类中私有成员

b.构造方法不能继承

成员变量和成员方法各自的访问特点（同样适用于多态）

  • 成员变量：看等号左边，左边是谁就用谁的成员变量，比如如果等号左边是子类，且没有，再去找父类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    public class fu {
        int num;
       }

    public class zi extends fu{
        int num;  //也叫num，两者重名
    }
    public static void main(String args[]){
        fu fu_ = new fu();
        zi zi_ = new zi();
        
        /*
        sout(fu.num)  		——>父类的num
        sout(zi.num)		——>子类的num
        */
        
        //多态：
        fu fu_2 = new zi();
     // sout(fu_2.num)		——>子类的num，因为继承中的成员变量看等号左边
        
    }

  • 成员方法：与成员变量相反，他看等号右边new的是谁，不做展示

方法的重写
1
2
3
4
5
1.概述:子类中有一个和父类方法名以及参数列表相同的方法
2.前提:继承
3.访问:看new的是谁,先调用谁中的,如果new的是子类,调用调用子类重写的方法,子类没有,找父类
4.检测是否为重写方法:在该方法上写
  @Override

注意事项：

1
2
3
4
5
6
1.子类重写父类方法之后,权限必须要保证大于等于父类权限(权限指的是访问权限)
  public -> protected -> 默认 -> private
2.子类方法重写父类方法,方法名和参数列表要一样 //和重载要求参数列表不同不一样，这个要求一样
3.私有方法不能被重写,构造方法不能被重写,静态方法不能被重写
4.子类重写父类方法之后,返回值类型应该是父类方法返回值类型的子类类型  //意思就是，子类的返回值如果是一个类的话，那这个类必须是父类返回值的那个类的子类
super和this
1
2
3
4
1.注意:new子类对象时,会先初始化父类(先走父类无参构造方法)
2.原因:
  每个构造方法的第一行,默认都会有一个super(),不写jvm自动提供一个
  super()代表的是父类无参构造

也就是说，子必有父，调用子类，如果不 显示使用super（有参）的话 父类一定会默认走一次无参构造

super的使用：

1
2
3
4
5
6
7
8
9
10
11
12
1.概述:代表的是父类引用
2.作用:可以调用父类中的成员
3.使用:
  a.调用父类构造方法-> 在子类中的构造中写
    super() -> 调用父类无参构造
    super(实参)  -> 调用父类有参构造
      
  b.调用父类成员变量:
    super.成员变量名
        
  c.调用父类成员方法:
    super.成员方法名(实参)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1.this概述:代表的是当前对象(哪个对象调用的this所在的方法,this就代表哪个对象)
2.作用:
  a.区分重名的成员变量和局部变量
  b.调用当前对象中的成员
3.使用:
  a.调用当前对象的构造:在构造中写
    this():调用当前对象的无参构造
    this(实参):调用当前对象的有参构造
  b.调用当前对象的成员变量:
    this.成员变量名
  c.调用当前对象的成员方法:
    this.成员方法名(实参)
4.注意:
  不管是super还是this,只要在构造中使用,都必须在第一行,所以二者不能同时手写出来

super 和 this 不能同时出现，因为两个都要在第一行

继承的特点：

只能单继承，不能多继承

想给private赋值或读取，那就要用到非私有的方法，getset也好，构造方法也行

抽象：

image-20250411215743850

抽象的真正意义：

  • 可以将抽象类看成是一类事物的标准,要求只要是属于这一类的,都必须要拥有抽象类中的方法,必须要给我实现
  • 怎么证明拥有了,怎么证明实现了呢?-> 重写