07_static_JavaBean_继承_super/this

ChoSeitaku

墨衍会员 · AI 创作全网分发码龄5年

关注

原创 2026-05-17 17:19:40 122 阅读 AI 写同款· GEO 优化 ›

Java学习10--面向对象进阶1 this：理解为一个变量，表示当前方法调用者的地址值；super：代表父类存储空间。阅读详情

第一章.static关键字

1.static关键字的介绍和使用

1.概述:代表的是静态关键字
2.使用:
   a.修饰一个成员变量
     权限修饰符 static 数据类型 变量名

   b.修饰一个方法
     权限修饰符 static 返回值类型 方法名(形参){
           方法体
           return 结果
    }

3.static的特点:
   a.静态成员属于类成员,不属于对象成员,非静态成员属于对象成员
   b.静态成员会随着类的加载而加载
   c.静态成员优先于对象存在
   d.凡是根据static关键字所在的类创建出来的对象,都可以共享这个静态成员

4.调用:
   类名直接调用

public class Student {
    int id;
    String name;
    static String classRoom;
}

public class Test01 {
    public static void main(String[] args) {
        Student.classRoom = "教研室11";
        Student s1 = new Student();
        s1.id = 1;
        s1.name = "张三";
        System.out.println(s1.id+"..."+s1.name+"..."+Student.classRoom);

        System.out.println("====================");
        Student s2 = new Student();
        s2.id = 2;
        s2.name = "李四";
        System.out.println(s2.id+"..."+s2.name+"..."+Student.classRoom);
    }
}

2.static成员的访问特点

1.在静态方法中能不能直接调用非静态成员 -> 不能
  new对象调用
2.在静态方法中能不能直接调用静态成员 -> 能
  a.直接调用
  b.类名调用
3.在非静态方法中能不能直接调用非静态成员->能
  a.直接调用
  b.new对象调用
4.在非静态方法中能不能直接调用静态成员 -> 能
  a.直接调用  
  b.类名调用

总结:

1.只要是调用非静态的成员,能直接调用就直接调用,不能直接调用就new对象调用

2.只要是调用静态的成员,能直接调用就直接调用,不能直接调用就类名调用

3.static使用场景

1.问题:既然静态成员这么好使用,那么将来能不能将所有的成员都定义成静态的呢? -> 不能
2.原因:如果将所有成员都定义成静态成员,那么静态成员不管是有用的,没用的,都会随着类的加载而加载,会占用内存   
3.static成员什么时候使用呢?
  定义工具类的时候,工具类中的成员都是静态成员
    
4.啥是工具类:拥有多个通用性功能的类
5.工具类怎么形成:
  将来我们发现在多个类中都要频繁实现某个功能,我们就不用在每个类中写重复代码,重复实现同一个功能了,我们可以将这些通用的代码封装到工具类中
      
6.工具类要求:
  a.构造私有化
  b.成员都是静态的

public class Test01 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
      /*  int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        System.out.println(sum);*/

        System.out.println(ArraysUtils.sum(arr));
    }
}

public class Test02 {
    public static void main(String[] args) {
        int[] arr = {3,3,4,5,3,3,54,6};
        /*int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }*/

        System.out.println(ArraysUtils.sum(arr));
    }
}

public class ArraysUtils {
    //构造私有
    private ArraysUtils(){}

    public static int sum(int[] arr){
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        return sum;
    }
}

除了工具类的成员是静态的,其他类的成员一般都是非静态的

第二章.JavaBean的作用

1.将来的javabean都是和数据库中的表做对应的
2.对应关系:
  a.类名 -> 表名
  b.属性名 -> 列名
  c.属性的类型 -> 每一列的类型
  d.属性值 -> 每个单元格中的数据
  e.对象 -> 每一行数据
    表中的第一行:User user = new User(1,"tom","111")
    表中的第二行:User user = new User(2,"jack","222")

1.1.javabean在开发中的实际运用_添加功能

利用javabean将页面上的数据封装起来,然后一层一层传递给dao层,在dao层中将封装的数据获取出来,添加到数据库中

1.2.javabean在实际开发中运用_查询功能

利用javabean将每一条查询出来的数据封装起来,然后将多个javabean放到一个集合中,最终响应给页面集合,在页面上遍历展示

第三章.对象数组

1.概述:数组中的元素存的是对象
2.注意:存的是对象,取出来的还是对象

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = 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 class Test01 {
    public static void main(String[] args) {
        /*
           1.存int型整数的数组:int[]
           2.存double型的数组:double[]
           3.存String型的数组:String[]
           4.存Person型的数组:Person[]
         */
        //定义存储Person对象的数组
        Person[] arr = new Person[3];
        Person p1 = new Person("张三", 18);
        Person p2 = new Person("李四", 20);
        Person p3 = new Person("王五", 22);
        //将三个对象放到数组中
        arr[0] = p1;
        arr[1] = p2;
        arr[2] = p3;

        //遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i].getName()+"..."+arr[i].getAge());
        }
    }
}

第四章.继承

1.什么是继承

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

1.父类怎么形成的:
  将共有的成员抽取出来,放到父类中,子类想直接用这些抽取出来的
成员,就直接继承父类即可

2.继承格式: extends
  子类 extends 父类{}

3.注意:
  a.构造方法不能继承,也不能被重写
  b.静态方法能继承,但是不能被重写
  c.子类可以继承父类中私有和非私有成员
     但是子类不能直接使用父类中私有成员

4.继承怎么学:
   不要从是否"拥有"层面学
   要从是否能直接"使用"层面学

5.继承:是一种代码的设计思想,理念
  可一使用也可以不使用,但是使用就比不使用强
  所以建议使用

2.继承如何使用

1.定义一个父类
2.定义一个子类 extends 父类
3.创建子类对象,调用父类中非私有成员

public class Employee {
    String name;
    int age;
    public void work(){
        System.out.println("员工正在工作...");
    }
}

public class Teacher extends Employee{
}

public class Test01 {
    public static void main(String[] args) {
        Teacher t1 = new Teacher();
        t1.name = "张三";
        t1.age = 18;
        System.out.println(t1.name+"..."+t1.age);
        t1.work();
    }
}

3.继承中,成员变量和成员方法的访问特点

3.1 成员变量

3.1.1 子类和父类中的成员变量不重名:

public class Fu {
    int numFu = 10;
}

public class Zi extends Fu{
    int numZi = 100;
}

public class Test01 {
    public static void main(String[] args) {
        Fu fu = new Fu();
        System.out.println(fu.numFu);

        Zi zi = new Zi();
        System.out.println(zi.numFu);
        System.out.println(zi.numZi);
    }
}

2.1.2.子类和父类中的成员变量重名

public class Fu {
    int numFu = 10;
    int num = 1000;
}

public class Zi extends Fu{
    int numZi = 100;
    int num = 10000;
}

public class Test01 {
    public static void main(String[] args) {
        Fu fu = new Fu();
        System.out.println(fu.numFu);
        System.out.println(fu.num);//父类的
        System.out.println("====================");
        Zi zi = new Zi();
        System.out.println(zi.numFu);
        System.out.println(zi.numZi);
        System.out.println(zi.num);//子类的
        System.out.println("====================");
        //多态创建对象方式->父类引用指向子类对象
        Fu fu1 = new Zi();
        System.out.println(fu1.num);//父类的
    }
}

继承中成员变量访问特点:看等号左边是谁,先调用谁中的成员变量

2.2 成员方法

2.2.1.子类和父类中的成员方法不重名:

public class Fu {
    public void methodFu(){
        System.out.println("父类方法");
    }
}

public class Test01 {
    public static void main(String[] args) {
        Fu fu = new Fu();
        fu.methodFu();

        System.out.println("=====================");
        Zi zi = new Zi();
        zi.methodZi();
        zi.methodFu();
    }
}

public class Zi extends Fu{
    public void methodZi(){
        System.out.println("子类方法...");
    }
}

2.2.2.子类和父类中的成员方法重名

public class Fu {
    public void methodFu(){
        System.out.println("父类方法");
    }

    public void method(){
        System.out.println("父类方法");
    }
}

public class Zi extends Fu{
    public void methodZi(){
        System.out.println("子类方法...");
    }

    public void method(){
        System.out.println("子类方法");
    }
}

public class Test01 {
    public static void main(String[] args) {
        Fu fu = new Fu();
        fu.methodFu();
        fu.method();//父类的方法

        System.out.println("=====================");
        Zi zi = new Zi();
        zi.methodZi();
        zi.methodFu();
        zi.method();//子类的方法

        System.out.println("=====================");

        //多态形式创建对象
        Fu fu1 = new Zi();
        fu1.method();//子类的方法
    }
}

继承中成员方法访问特点:看等号右边是谁,先调用谁中的方法,子类没有找父类

4.方法的重写

1.前提:必须有子父类继承关系
2.概述:子类中有一个和父类方法名以及参数列表一样的方法,子类中的这个方法就叫做重写的方法
3.如何检测这个方法是否为重写的方法:
  方法上加上注解: @Override
4.如何访问重写的方法:
  看new的是谁,new的子类,调用方法一定是重写的方法

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

public class Zi extends Fu{

    @Override
    public void method(){
        System.out.println("子类方法");
    }
}

public class Test01 {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.method();
    }
}

4.1.注意事项

1. 子类方法重写父类方法，必须要保证权限大于等于父类权限。(权限修饰符)
   public  -> protected -> 默认 -> private 
2. 子类方法重写父类方法,方法名和参数列表都要一模一样。
3. 私有方法不能被重写,构造方法不能被重写,静态方法也不能重写
4. 子类重写父类方法之后,返回值类型应该是父类方法返回值类型的子类类型  
   一般情况下,子类重写父类方法之后,都一样
5. 私有方法可以继承但是不能被重写,构造方法不能被继承,也不能被重写,静态的能继承,但不能重写

/**
 * Object类: 所有类的父类
 * String类:String也属于Object的子类
 */
public class Fu {
    public void method(){
        System.out.println("父类方法");
    }

    public Object method01(){
        System.out.println("父类方法01");
        /*
           return null没有特殊含义
           仅仅是为了让这个方法有个返回值,不报错
         */
        return null;
    }
}

public class Zi extends Fu{
    @Override
    public void method(){
        System.out.println("子类方法");
    }

    @Override
    public String method01(){
        System.out.println("子类方法01");
         /*
           return null没有特殊含义
           仅仅是为了让这个方法有个返回值,不报错
         */
        return null;
    }
}

4.2.使用场景

当子类想对父类中的某个方法进行升级改造,就可以在子类中重写父类中的方法,在子类中做具体实现

public class OldPhone {
    public void call(){
        System.out.println("打电话");
    }
    public void sendMessage(){
        System.out.println("发短信");
    }
    public void show(){
        System.out.println("显示手机号");
    }
}

public class NewPhone extends OldPhone{
    @Override
    public void show(){
        System.out.println("显示手机号");
        System.out.println("显示归属地");
        System.out.println("显示头像");
    }
}

public class Test01 {
    public static void main(String[] args) {
        NewPhone newPhone = new NewPhone();
        newPhone.call();
        newPhone.sendMessage();
        newPhone.show();
    }
}

5.继承的特点

1.继承只支持单继承,不能多继承 -> 一个子类不能同时继承多个父类
  public class Zi extends Fu1,Fu2{} -> 不行
2.继承支持多层继承
  public class Zi extends Fu{}
  public class Fu extends Ye{}
3.一个父类可以有多个子类
  public class A extends B{}
  public class C extends B{}

6.继承中构造方法的特点

1.继承中构造方法的特点:
  创建子类对象时,先初始化父类(先调用父类无参构造)
2.原因:
  在构造方法的第一行默认有一个super(),不写也有
3.super()代表的是调用父类无参构造

public class Fu {
    public Fu(){
        //super();
        System.out.println("父类无参构造方法");
    }
}

public class Zi extends Fu{
    public Zi(){
        //super();
        System.out.println("子类无参构造方法...");
    }

    public Zi(String name){
        //super();
        System.out.println("子类有参构造方法...");
    }
}

public class Test01 {
    public static void main(String[] args) {
        Zi zi = new Zi();
        Zi zi1 = new Zi("张三");

    }
}

7.super和this的具体使用

7.1 super的具体使用

1.概述:super代表的是父类引用
2.作用:在子类中调用父类的成员(成员变量,成员方法,构造)
3.使用:
  调用父类构造方法:在子类的构造中使用
                super() 调用父类无参构造
                super(实参) 调用父类有参构造
      
  调用父类成员变量:super.成员变量名
               
  调用父类成员方法:super.方法名(实参)

public class Fu {
    int num = 10;
    public Fu(){
        System.out.println("父类无参构造方法");
    }

    public Fu(String name){
        System.out.println("父类有参构造方法");
    }

    public void show(){
        System.out.println("父类方法");
    }
}

public class Zi extends Fu {
    int num = 100;
    public Zi(){
        super();//默认调用父类的无参构造方法
        System.out.println("子类无参构造方法...");
    }

    public Zi(String name){
        super(name);//默认调用父类的有参构造方法
        System.out.println("子类有参构造方法...");
    }

    @Override
    public void show(){
        System.out.println(num);//子类中的100
        System.out.println(super.num);//父类中的10
        System.out.println("子类方法...");

        super.show();//父类方法
    }
}

public class Test01 {
    public static void main(String[] args) {
        Zi zi = new Zi();
        Zi zi1 = new Zi("张三");

        System.out.println("===================");

        zi.show();

        System.out.println("===================");

        zi.show();
    }
}

7.2 this的具体使用

1.概述:代表的是当前对象
2.作用:调用当前对象中的成员
3.使用:
  调用当前对象的构造: this()  或者 this(实参)
  调用当前对象的成员变量: this.成员变量名
  调用当前对象的成员方法: this.方法名(实参)

public class Person {
    String name = "张三";
    public Person(){
        //this("abc");//调用本类有参构造
        System.out.println("无参构造");
    }
    
    public Person(String name){
        this();//调用本类无参构造
        System.out.println("有参构造");
    }
    public void show(){
        String name = "李四";
        System.out.println(name);//李四
        System.out.println(this.name);//张三
        System.out.println("show方法...");
    }
    
    public void method(){
        //this.show();
        show();
        System.out.println("method方法");
    }
}

注意:super,this如果在构造中使用,都必须要在构造第一行,所以this和super在构造方法中不能同时出现

8.问题:如何为父类中private的成员变量赋值

8.1.利用set赋值

public class Employee {
    private String name;
    private int age;

    public Employee() {
    }

    public Employee(String name, int age) {
        this.name = name;
        this.age = 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 class Teacher extends Employee{
}

public class Test01 {
    public static void main(String[] args) {
        Teacher t1 = new Teacher();
        t1.setName("张三");
        t1.setAge(18);
        System.out.println(t1.getName()+"..."+t1.getAge());
    }
}

8.2.利用构造方法赋值

public class Employee {
    private String name;
    private int age;

    public Employee() {
    }

    public Employee(String name, int age) {
        this.name = name;
        this.age = 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 class Teacher extends Employee{
    public Teacher() {
    }

    public Teacher(String name, int age) {
        super(name, age);
    }
}

public class Test01 {
    public static void main(String[] args) {
        Teacher t1 = new Teacher();
        t1.setName("张三");
        t1.setAge(18);
        System.out.println(t1.getName()+"..."+t1.getAge());

        System.out.println("===================");
        Teacher t2 = new Teacher("李四",20);
        System.out.println(t2.getName()+"..."+t2.getAge());
    }
}