javaSE(基础四) 面向对象(二)

最新推荐文章于 2022-07-04 20:22:59 发布

yz_hope

最新推荐文章于 2022-07-04 20:22:59 发布

阅读量132

点赞数 2

分类专栏： javaSE 文章标签： java

本文链接：https://blog.csdn.net/yz_hope/article/details/110261463

版权

javaSE 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

本文主要介绍了Java面向对象的几个核心概念：构造器的定义与作用，包括构造器的重载；this关键字的使用场景，如在构造器中的应用和解决同名变量问题；static关键字的含义，以及静态变量和静态方法的使用规则；重点讨论了封装的概念，包括封装的定义、实现方式以及设置器setter和访问器getter的重要作用。通过对这些概念的深入理解，有助于提升Java编程能力。

摘要由CSDN通过智能技术生成

javaSE(基础四) 面向对象(二)

构造器

构造器|构造方法|构造函数:
就是特殊的方法

使用:
必须只能跟随new关键字使用
作用:
只能new关键字才能创建对象,构造器只能为对象初始化信息(就是为对象的成员变量赋值) ,不能创建对象
定义:
修饰符类名(){
}
构造器不需要定义返回值和void
可以定义return,但是不需要return带出返回值

一个类中如果没有显示定义构造器,编译器会自动会我们提供一个空构造
如果有显示定义构造器,编译器不会为我们提供任何空构造

注意 :
自定义的模板类,都应该至少提供一个空构造

构造方法的重载

1)方法具有重载的特性,构造器也可以重载
2)重载构造器的调用使用,根据new对象后的()匹配参数列表

 //通过带参构造器,创建对象的同时为成员赋值(第一次赋值->初始化)
        Dog  dog2 = new Dog("多多",2,"中华田园犬");

this关键字

指代当前new对象
1)在构造器的首行可以调用本类中的其他构造器
this(实参);
注意: 1)一定要使用在构造器的首行才行
2)不要相互调用,效果类似死循环
2)区分同名变量问题
1)成员变量与局部变量同名问题,this.调用成员,否则默认就近原则
2)如果出现同名问题,指代成员this.不能省略,如果没有同名问题,哪有用哪个,当找到成员的时候,this.可以省略

3)在构造器中this关键字指代当前new的对象
4)在成员方法中的this,默认指代当前调用成员方法的对象

注意: this不能使用在static修饰方法中

public Cat(){
    System.out.println("喵喵...");
}

public Cat(String name){
    this(); //调用Cat()方法
    this.name=name;
    System.out.println(this.name+"正在吃鱼...");
}

public Cat(int age,String type,String name){
    this(""); //调用Cat(String name)方法
    this.age=age; //区分成员变量和局部变量同名问题,指代局部变流量
    this.type=type;
    this.name=name;
    System.out.println(age+"岁"+type+name+"正在抓蝴蝶...");
}

static关键字

static 静态的
修饰变量
修饰方法
修饰块
修饰类

1)被static修饰的变量–>静态变量|类变量
2)被static修饰的方法–>静态方法|类方法

静态内容的使用方式:
类名.静态变量名
类名.静态方法名()
引用.静态变量名
引用.静态方法名()

静态的内容是属于类的,可以直接跟随类名使用,可以跟随对象使用
成员的内容是属于对象的,是能跟随对象使用,现有对象才有成员

1)静态的变量是独一份的,在类第一次加载到内存之后就初始化,当前类多个对象共享的,在方法区中的静态区中
2)在静态的内容中,只能直接使用静态的内容,不能直接使用成员的内容,通过对象使用成员
3)在成员内容中,可以直接使用静态内容,可以直接使用成员内容
4)static关键字只能修饰成员,不能修饰局部–>成员修饰符

先静态后成员
先父类后子类

public class StaticTest {
    public static int id;
    public int age;
    public static void main(String[] args) {
        StaticTest staticTest = new StaticTest();
        System.out.println(StaticTest.id);   // 类名调用 0
        System.out.println(staticTest.age);   //对象调用 0

        staticTest.Change(); //id= 1  age= 0   //id=1 staticTest.age=1
        System.out.println(StaticTest.id); //1
        System.out.println(staticTest.id);  //0/1(T)  id是静态方法,在方法区,所有值1
        System.out.println(staticTest.age);  //age=0
        staticTest.Change();  ///  2  2/0(T)  //2  2/1(T)
        System.out.println(id);  //2
        System.out.println(staticTest.age);  //0
    }
    public void Change() {
        StaticTest staticTest = new StaticTest();
        staticTest.age++;  // 1
        StaticTest.id++;  //  1
        System.out.println("In Change(): id = " + id + " age = " + age);  //id= 1  age= 1  //
        System.out.println("In Change(): id = " + id + " staticTest.age = " + staticTest.age);
    }
}

block代码块

块block
自成作用域 {}

普通语句块|局部代码块{} : 定义在方法中执行时机: 跟随所在方法调用
构造块{} : 类中方法外执行时机: new 创建对象
静态块static{} : 类中方法外执行时机: 类第一次加载
同步块

构造块代码在构造器代码之前执行,如果一个类中存在多个构造块,从上到下一次执行
在类第一次加载完成之后就执行,并且只执行一次
如果一个类中存在多个静态块,从上到下一次执行
如果一个类中存在多个静态内容,从上到下一次加载

******静态块–>main–>构造块–>构造器

public class BlockTest {
        //找到打印顺序+结果
        public static int a = 0;
        {
            a = 10;
            System.out.println("3 、非静态代码块执行a=" + a); // 3. 10  构造块
        }
        static {
            a = 6;
            System.out.println("1 、静态代码块执行a=" + a); // 1. a=6
        }
        public BlockTest() {
            this(a); //
            System.out.println("6 、"+a);  // 5. 10
            System.out.println("7 、无参构造方法执行a=" + a); // 10
        }
        public BlockTest(int n) {
            /*{
                a = 10;
                System.out.println("  、非静态代码块执行a=" + a); // 3. 10  构造块
            }*/
            System.out.println("4 、"+n); // 4. 6
            System.out.println("5 、"+a);//     10
        }
        public static void main(String[] args) {
            System.out.println("2 、main"); // 2. \main
            BlockTest tsc = new BlockTest();
        }
    }