JavaSE-day07

最新推荐文章于 2024-07-24 17:27:32 发布

Gang__lang

最新推荐文章于 2024-07-24 17:27:32 发布

阅读量34

点赞数

文章标签： java Powered by 金山文档

本文链接：https://blog.csdn.net/Gang__lang/article/details/128856257

版权

构造函数：

每次new对象时，都会触发对应类中的构造方法

每个类中都会默认存在一个没有参数的构造方法，如果你提供了其他的构造函数，默认的无参构造就会消失，如果你还想要不传参就创建对象，那就必须自己写无参构造

构造方法的格式：与本类类名相同，且没有返回值类型的方法例: public 类名{函数体}

每次创建对象都会执行一个构造方法构造方法的作用：就是用来创建对象的

全参构造不仅可以创建对象，还可以给对象赋值

以下是构造函数的入门案例：

public class TestConstructor {
    public static void main(String[] args) {
        //4.创建Person类的对象
        /*1.每次new对象时，都会触发对应类中的构造方法*/
        /*2.每个类中都会默认存在一个没有参数的构造方法
        * 如果你提供了其他的构造函数，默认的无参构造就会消失
        * 如果你还想要不传参就创建对象，那就必须自己写无参构造*/
        Person p1=new Person();
        System.out.println(p1.name);
        System.out.println(p1.age);
        System.out.println(p1.address);
        p1.eat();
        /*4.每次创建对象都会执行一个构造方法
        * 构造方法的作用：就是用来创建对象的*/
        Person p2=new Person("狼",5);
        /*5.全参构造不仅可以创建对象，还可以给对象赋值*/
        Person p3=new Person("张三",6,"狼牙山");
        System.out.println(p2.address);
        System.out.println(p3.address);
    }
}
//1.创建Person类，描述人这一类事物
class Person{
    //2.定义属性
    String name;
    int age;
    String address;//住址
    /*3.构造方法的格式：与本类类名相同，且没有返回值类型的方法*/
    //5.1创建本类的无参构造   默认存在
    public Person(){
        System.out.println("无参构造");
    }
    //5.2创建本类的有参构造
    public Person(String name,int age){
        this.name=name;
        this.age=age;
        System.out.println("我是Person类的含参构造");
    }
    //5.3创建本类的全参构造--此构造方法的参数与本类的属性一致

    public Person(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
        System.out.println("我是Person类的全参构造");
    }
    public Person(int age,String name, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }
    //3.功能--方法
    public void eat(){
        System.out.println("端起我的饭碗");
    }
}

构造代码块和局部代码块

构造代码块：{}

1.位置：类里方法外

2.执行时机：每次创建对象时都会执行构造代码块，并且构造代码块优先于构造方法执行

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

局部代码块：{}

1.位置：方法里

2.执行时机：在调用本局部代码块所处的方法时才会执行

3.作用：用于控制变量的作用范围，变量的作用范围越小越好（该变量只能在该代码块中使用）

执行速度

执行顺序：构造代码块 -->构造方法-->普通方法-->局部代码块

分析：

1.当创建对象时，会触发构造函数

2.创建对象时，也会触发构造代码块，并且构造代码块会优先于构造方法执行

3.创建完对象后，可以调用对象的普通方法

4.如果普通方法中有局部代码块，那么就会执行局部代码块

以下是测试代码块的案例

public class TestBlock {
    public static void main(String[] args) {
        Pig p1=new Pig();
        Pig p2=new Pig("狼");
        Pig p3=new Pig("lang",5);
        System.out.println(p2.age);
        System.out.println(p3.age);
        p1.eat();
        p2.eat();
    }
}
//1.创建一个小猪类用来测试
class Pig{
    //2.定义属性
    String food;//食物
    int age;//年龄
    //3.创建普通方法
    public void eat(){
        System.out.println("小猪爱吃菜叶子");
        //8.创建本类的局部代码块
        {
            /*局部代码块：{}
            1.位置：方法里
            2.执行时机：在调用本局部代码块所处的方法时才会执行
            3.作用：用于控制变量的作用范围，变量的作用范围越小越好
            * */
            System.out.println("我是一个局部代码块");
            int i=100;
            System.out.println(i);//局部代码块中的局部变量i只能在代码块里使用
        }
    }
    //7.创建本类的构造代码块
    {
        /*构造代码块：{}
        * 1，位置：类里方法外
        * 2.执行时机：每次创建对象时都会执行构造代码块，并且构造代码块优先于构造方法执行
        * 3.作用：用于提取所有构造方法的共性功能
        * */
        System.out.println("我是一个构造代码块");
        System.out.println("黑猪肉");//相当于在每个构造方法中都写入了这条语句
    }
    //4.1无参构造
    public Pig() {
        System.out.println("我是Pig类的无参构造");
    }
    //4.2含参构造
    public Pig(String a){
        System.out.println("我是Pig类的含参构造"+a);
    }
    //4.2全参构造
    public Pig(String food, int age) {
        this.food = food;
        this.age = age;
        System.out.println("我是Pig类的全参构造");
    }
}

继承

1.通过extends关键字建立子类与父类的继承关系格式：子类 extends 父类

2.Java只支持单继承，一个子类只能有一个父类，一个父类可以有多个子类

3.继承还具有传递性，爷爷的功能会传给父类，父类的功能会传递给子类

4.子类可以用于自己独有的方法，实现功能的拓展

5.子类继承父类以后，可以使用父类的所有非私有资源这个私有资源由于被private修饰，所以没有访问权限

6.继承时is a的关系，例如：小猫是小动物，miaomiao是一只小猫

继承要求子类必须是父类的一种下属类型，依赖性非常强，强耦合

/*本类用于继承的入门案例*/
public class TestExtends {
    public static void main(String[] args) {
        //5.分别创建3个类的对象
        Animal animal=new Animal();
        Cat cat=new Cat();
        MiaoMiao miaoMiao=new MiaoMiao();
        //6.利用对象调用方法
        /*3.继承还具有传递性，爷爷的功能会传给父类，父类的功能会传递给子类*/
        animal.eat();
        cat.eat();
        miaoMiao.eat();
    }
}
//1.创建小动物类--爷爷类
/*1.通过extends关键字建立子类与父类的继承关系  格式：子类 extends 父类
* 2.Java只支持单继承，一个子类只能有一个父类，一个父类可以有多个子类*/
class Animal{
    //4.添加爷爷类的普通方法
    public void eat(){
        System.out.println("小动物们吃啥都行");
    }
}
//2.创建小猫类--父类
/*6.继承时is a的关系，例如：小猫是小动物，miaomiao是一只小猫
* 继承要求子类必须是父类的一种下属类型，依赖性非常强，强耦合*/
class Cat extends Animal{
    //7.定义父类中的属性
    int a=10;//普通属性
    private int b=100;//私有属性
}
//3.创建MiaoMiao类--子类
class MiaoMiao extends Cat{
    /*4.子类可以用于自己独有的方法，实现功能的拓展*/
    //8.定义子类方法
    public void studyJava(){
        System.out.println("正在学Java");
        System.out.println(a);
        /*5.子类继承父类以后，可以使用父类的所有非私有资源
        * 注意：这个私有资源由于被private修饰，所以没有访问权限*/
//        System.out.println(b);//私有资源被限制访问
    }

补充说明：

1.子类在创建对象时，默认会先调用父类的构造方法

2.原因是子类构造函数中的第一行默认存在super();--表示调用父类的无参构造

3.当父类，没有无参构造时，可以通过super（参数）调用父类的其他含参构造

子类必须调用一个父类的构造函数，不管是无参还是含参，选一个即可

4.构造方法不可以被继承！因为语法的原因：要求构造方法的名字必须是本类类名

不能在子类中出现一个父类的构造方法