Java（day07）构造、继承、重载

关注

原创最新推荐文章于 2026-07-11 09:29:01 发布 308 阅读 AI 写同款· GEO 优化 ›

ANSYS Help USER300 USER 300概述单元描述输入数据假设与限制条件概述单元描述 Mechanical APDL提供了一种方便的方法来创建自定义的单元，命名为USER300，可以创建几乎任何单元类型。 UserElem子程序为Mechanical APDL在单元类型创建上提供了一个接口，可传递用户自定义单元创建时所需的所有数据，然后从自定义单元返回所有数据和结果，以更新数据库和文件。因为通过接口可以访问数据库和文件信息，所以很少需要了解Mechanical APDL数据库程序和文件结构。该接口还提供了获取Mechanic 阅读详情

重载：

同类同方法不同参数

构造：

概念

与类同名,且没有返回值类型,可以含参也可以不含参

在这里插入图片描述

特性

如果提供其他的构造函数，默认的无参构造会被覆盖

每次创建对象时，都会执行构造方法

每一个类中都默认有一个没有参数的构造方法，每次new对象时，都会自动触发这个类对应的构造方法

作用

用于创建对象

package cn.tedu.oop;
/*本类用于测试构造方法*/
public class TestConstructor {
    public static void main(String[] args) {
        /*每一个类中都默认有一个没有参数的构造方法
        * 每次new对象时，都会自动触发这个类对应的构造方法*/
        Persion p=new Persion();
        System.out.println(p.name);
        System.out.println(p.age);
        System.out.println(p.address);
        p.eat();
        Persion p2=new Persion();
        Persion p3=new Persion("李白");
        Persion p4=new Persion("李逵",32,"柳树下");
        System.out.println(p4.name);
        System.out.println(p4.age);
        System.out.println(p4.address);
        System.out.println(p3.name);

    }
}
class Persion{
    String name;
    int age;
    String address;
    public Persion(){
        System.out.println("我是persion类的无参构造");
    }
    //无参构造
    public void eat(){
        System.out.println("干饭不积极，思想有问题~");
    }
    public Persion(String name){
        this.name=name;
        System.out.println("我是persion的含参构造");
    }
    //全参构造方法
    public Persion(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
        System.out.println("我是persion的全参构造");
    }
}
运行结果：
我是persion类的无参构造
null
0
null
干饭不积极，思想有问题~
我是persion类的无参构造
我是persion的含参构造
我是persion的全参构造
李逵
32
柳树下
李白

构造代码块：｛｝

位置:类里方法外

执行时间：每次创建对象时都会执行构造代码块，且优先构造方法执行

作用：用于提取所有构造方法的共性功能

package cn.tedu;
/*本类用于测试代码块*/
public class TestBlock {
    public static void main(String[] args) {
        //System.out.println("666");
        Pig p1=new Pig();
        Pig p2=new Pig("好");
        Pig p3=new Pig("菜",6);
    }
}
class Pig{
    String food;
    int age;
    {
        System.out.println("我是构造代码块");
    }
    public  Pig(){
        System.out.println("我是无参构造");
    }
    public  Pig(String food){
        System.out.println("我是含参构造"+food);
    }
    public  Pig(String food,int age){
        this.age=age;
        this.food=food;
        System.out.println("我是全参构造");
    }
    public void eat(){
        System.out.println("小猪爱吃菜叶子");
    }

}

执行结果：
我是构造代码块
我是无参构造
我是构造代码块
我是含参构造好
我是构造代码块
我是全参构造

局部代码块：｛｝

位置:类里方法里

执行时间：调用局部代码块所处的方法时执行

作用：用于控制变量的作用范围，变量的作用范围越小越好

package cn.tedu;
/*本类用于测试代码块*/
public class TestBlock {
    public static void main(String[] args) {
        //System.out.println("666");
        Pig p1=new Pig();
        Pig p2=new Pig("好");
        Pig p3=new Pig("菜",6);
        p1.eat();
    }
}
class Pig{
    String food;
    int age;
    {
        System.out.println("我是构造代码块");
    }
    public  Pig(){
        System.out.println("我是无参构造");
    }
    public  Pig(String food){
        System.out.println("我是含参构造"+food);
    }
    public  Pig(String food,int age){
        this.age=age;
        this.food=food;
        System.out.println("我是全参构造");
    }
    public void eat(){
        System.out.println("小猪爱吃菜叶子");
        {
            System.out.println("我是一个局部代码块");
        }
    }

}
运行结果：
我是构造代码块
我是无参构造
我是构造代码块
我是含参构造好
我是构造代码块
我是全参构造
小猪爱吃菜叶子
我是一个局部代码块

this关键字

1.当成员变量和局部变量同名时，可以使用this关键字指定本类的成员变量

package cn.tedu.oop2;
/*本类测试this*/
public class TestThis {
    public static void main(String[] args) {
        Dog d=new Dog();
        d.eat();
    }
}
class Dog{
    int count=666;
    int sum=100;
    public void eat(){
        int sum=10;
        System.out.println(sum);
        System.out.println(count);
        System.out.println(this.sum);
    }
}
执行结果：
10
666
100

2.在含参构造函数中调用无参构造函数，且必须写在第一行

package cn.tedu.oop2;
/*用来测试this*/
public class TestThis2 {
    public static void main(String[] args) {
        cat c1=new cat();
        cat c2=new cat("下午好");
    }
}
class cat{
    public cat(){
        this("你好");
        System.out.println("小猫的无参构造");
    }
    public cat(String s){
        //this();
        System.out.println("小猫的含参构造"+s);
    }
}
执行结果：
小猫的含参构造你好
小猫的无参构造
小猫的含参构造下午好

继承（extends）

java只能单继承，一个子类不可以有多个父类，但一个父类可以有多个子类

子类继承父类后，不能继承父类的私有资源

super

当父类的成员变量和子类的成员变量同名时，可以使用super关键字指定父类的成员变量

package cn.tedu.oop2;
//用于测试继承中变量的使用
public class TestExtends1 {
    public static void main(String[] args) {
        Son s=new Son();
        s.study();
        System.out.println(s.count);
    }
}
class Father{
    int sum=1;
    int count=2;
}
class Son extends Father{
    int sum=10;
    public void study(){
        System.out.println("good good study,day day up");
        int sum=100;
        //打印子类的局部变量sum
        System.out.println(sum);
        //打印子类的成语变量sum
        System.out.println(this.sum);
        System.out.println(super.sum);
    }
}
执行结果：
good good study,day day up
100
10
1
2

子类在创建对象时，默认会先调用父类的构造函数

子类必须调用父类的构造方法，不论是无参还是含参

package cn.tedu.oop2;
//本类用于测试继承中的构造方法
public class TestExtends {
    public static void main(String[] args) {

        Son2 s=new Son2();
    }
}
class Father2{
    public Father2(){
        System.out.println("我是父类的无参构造");
    }
    public Father2(String s){
        System.out.println("我是父类的含参构造"+s);
    }

}
class Son2 extends Father2{
    public Son2(){
        super();
        System.out.println("我是子类的无参构造");
    }
}

执行结果：
我是父类的无参构造
我是子类的无参构造

重点

创建对象的同时就已经调用了构造方法

super:1.作用于不同类，子类与父类成员变量同名时，子类可以通过super.调用父类的成员变量

package cn.tedu.oop2;
//用于测试继承中变量的使用
public class TestExtends1 {
    public static void main(String[] args) {
        Son s=new Son();
        s.study();
    }
}
class Father {
    int sum = 1;
}
class Son extends Father{
    int sum=10;
    public void study(){
        int sum=100;
        System.out.println(sum);
        System.out.println(super.sum);
    }
}
运行结果：
100
1

2.作用于不同类中，子类可以通过super（）调用父类的无参构造，也可以通过super（参数）调用父类的含参构造方法

package cn.tedu.oop2;
//本类用于测试继承中的构造方法
public class TestExtends {
    public static void main(String[] args) {

        Son2 s=new Son2();
    }
}
class Father2{
    public Father2(){
        System.out.println("我是父类的无参构造");
    }
    public Father2(String s){
        System.out.println("我是父类的含参构造"+s);
    }

}
class Son2 extends Father2{
    public Son2(){
        super("哈哈");
        System.out.println("我是子类的无参构造");
    }
}

运行结果：
我是父类的含参构造哈哈
我是子类的无参构造

3.子类在创建对象时，默认会调用父类的方法，因为子类的构造函数中的第一行默认存在super（）

package cn.tedu.oop2;
//本类用于测试继承中的构造方法
public class TestExtends {
    public static void main(String[] args) {

        Son2 s=new Son2();
    }
}
class Father2{
    public Father2(){
        System.out.println("我是父类的无参构造");
    }
    

}
class Son2 extends Father2{
    public Son2(){

        System.out.println("我是子类的无参构造");
    }
}

运行结果：
我是父类的无参构造
我是子类的无参构造