Java学习Day5

逃离我推掉我的手 2023-02-24 15:28 13阅读 0赞

# 构造方法相关 #

**构造方法:调用的方式:类名+()**  
作用:对对象的属性进行初始化,如果我们自己不创建构造方法,系统会调用默认的无参构造方法

**自己创建构造方法:**  
分类:  
1.创建无参的构造方法:会将成员变量默认初始化成null/false/0  
2.创建有参的构造方法:会将成员变量进行初始化并赋值,赋值成你传进来的参数

有参的构造方法
    功能:在对属性初始化后,并完成赋值
    参数一般写成与要被赋值的成员变量同名
    当成员变量与局部变量同名时,方法内部默认识别的是局部变量---这里依据的是就近原则(在内存中离方法的远近判断)
    解决方法:使用this调用成员变量,加以区分

**构造方法的基本构成:  
修饰词 方法名字(参数列表)\{  
方法体  
\}**  
注意点:1.没有返回值这一项 2.方法名必须与当前的类名同名

**使用构造方法的注意点:**  
1.一旦创建了自己的构造方法,就不会再去调用系统默认的构造方法  
2.多个构造方法之间是重载的关系

**this**: 是一种引用数据类型,本身是一个关键字,代表的是当前的对象,保存的是当前对象的地址  
场景:当我们想在当前类的内部拿到当前对象的引用时,可以使用this

**this的功能总结**:  
1.用来区分成员变量和局部变量  
2.可以在构造方法内部调用其他重载的构造方法,提高代码的复用性,简化代码

**注意点**:  
1.不能自己调用自己—死循环  
2.不能相互调用----死循环  
3.this充当构造方法时,必须放在第一行  
4.this在作为方法的时候,只能充当构造方法,不能作为其他方法  
5.this的使用范围就是当前类的内部  
6.只有在非静态方法中,才可以使用this.

public class Demo5 {
        
        public static void main(String[] args) {
        
            //1.一旦创建了自己的构造方法,就不会再去调用系统默认的构造方法
            //Dog dog = new Dog();
            Dog dog1 = new Dog("chen",170,20);
            System.out.println(dog1.name);
        }
    }
    
    class  Dog{
        
        String name;
        int age;
        int height;
    
        //1.一旦创建了自己的构造方法,就不会再去调用系统默认的构造方法
        public  Dog(){
        
            //this();//自己调用自己----死循环
            System.out.println("自己创建的无参构造方法");
        }
    
        public  Dog(String name,int age){
        
            //this("bing",4,5);  两个构造方法相互调用----死循环
            this.name = name;
            this.age = age;
        }
    
        //有参的构造方法
        //功能:在对属性初始化后,并完成赋值
        //参数一般写成与要被赋值的成员变量同名
        //当成员变量与局部变量同名时,方法内部默认识别的是局部变量---这里依据的是就近原则(在内存中离方法的远近判断)
        //解决方法:使用this调用成员变量,加以区分
        public Dog(String name,int age,int height){
        
    //        this.name = name;
    //        this.age = age;
            //System.out.println("hehe");  //this充当构造方法时,必须放在第一行
            this(name,age);//调用有两个参数的构造方法
            this.height = height;
        }
    
        public void  run(){
        
            System.out.println("run");
        }
    }

## 代码块: ##

**静态代码块**:随着**类的加载**而加载,在整个程序执行过程中**只执行一次**,执行顺序**优先于main**  
构成:static+\{\}  
作用:对类进行初始化  
**构造代码块**:随着**对象的加载**而加载,每次创建对象的时候**都会执行一次**,执行顺序**优先于构造方法.**  
构成:\{\}  
作用:对对象进行初始化

public class Demo8 {
        
        //	//构造代码块儿
    //	{
        
    //		System.out.println("hehe");
    //	}
    //	//静态代码块儿
    //	static {
        
    //
    //	}
        static {
        
            System.out.print("a");
        }
        public static void main(String[] args) {
        
            Pig pig = new Pig();
            Pig pig1 = new Pig();
            Pig pig2 = new Pig();
            Pig pig3 = new Pig();
            pig.show();
        }
        static {
        System.out.print("b");
        }
    }
    
    class Pig{
        
        static {
        System.out.print("c");}
    
        {
        System.out.print("d");}
    
        public Pig() {
        System.out.print("e");}
    
        public void show() {
        System.out.print("f");}
    }

# static #

**总结成员变量的特点：** 这里指非静态成员  
1.在创建对象时会赋默认值  
2.可以在类中定义变量的时候，直接赋值  
3.非静态的成员变量可以在除了static修饰的方法外任何地方使用

**成员变量和局部变量的区别：**  
1.作用域：成员变量是针对整个对象，局部变量从定义开始到所在的函数/if/for结束  
2.默认值：成员变量会有默认值,数值型为0，字符型为null；局部变量没有默认值，要想使用必须先赋值  
3.释放机制：成员变量更对象保持一致，通过垃圾回收机制回收，局部变量使用完立即释放。  
4.存放位置：成员变量放在堆区的对象中，局部变量放在栈区的方法中。

**一般将成员分成两类：静态的成员（static）和非静态的成员。**  
静态的成员：静态的成员变量和成员方法—可以使用引用调用，也可以使用类名调用  
非静态的成员：非静态的成员变量和成员方法—只能使用引用调用  
static：这是一个关键字，被static修饰的成员就变成了静态的，具有保值功能。

**为什么可以直接通过类名调用静态的成员？**  
当成员被static修饰之后就变成了静态的，会在class生成的同时放在静态方法区中一份，而静态方法区的特点是内容随着程序的结束而释放，所以对象创建与否不能影响他们的调用，所以可以直接用类名调用  
![在这里插入图片描述][20200714204439114.png]![在这里插入图片描述][20200714204418335.png]

**静态的成员方法和非静态的成员方法优先使用哪一个？**  
–优先使用静态的成员方法  
–静态的方法比非静态的效率高，节省内存。  
–静态方法可以不用创建对象，直接用类名调用，非静态只能通过引用调用  
注意：有一种情况例外：当方法中必须使用非静态的成员变量的时候，这时候必须使用非静态的成员方法  
总结：被static修饰的成员变量会变成静态的成员变量，成员方法会变成静态的成员方法。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbnl1YW5fOTg1_size_16_color_FFFFFF_t_70][]

# 面对对象的三大特性 #

## 封装性 ##

> 使用者对类内部定义的属性(对象的成员变量)的直接操作会导致数据的错误、混乱或安全性问题。在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。
> 
> 封装是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。要访问该类的代码和数据，必须通过严格的接口控制。
> 
> 封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。
> 
> 封装原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问。
> 
> 封装的好处（优点）：
> 
> 1）通过隐藏对象的属性来保护对象内部的状态（隐藏信息、实现细节）。
> 
> 2）提高了代码的可用性和可维护性，因为对象的行为可以被单独的改变或者是扩展（将变化隔离，类内部的结构可以自由修改，增加内部实现部分的可替换性）。
> 
> 3）禁止对象之间的不良交互提高模块化（良好的封装能够减少耦合）。
> 
> 4）可以对成员变量进行更精确的控制。
> 
> 5）容易保证类内部数据间的一致性，从而提高软件的可靠性。

————————————————  
版权声明：出自CSDN博主「下班后的爪哇菌」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。  
原文链接：https://blog.csdn.net/lxxiang1/article/details/81258324

public class Demo7 {
        
    //    开枪射击
         public static void main(String[] args) {
        
             //脏数据：程序中出现的不符合逻辑的数据
             /*
             原因：让用户直接将数据给了成员变量
             解决：1.不让他直接传值---将成员变量私有化，写一个公共的方法
                  2.对数据进行过滤，将过滤后的数据交给成员变量
              */
             Gun g = new Gun();
             g.addbulletnumber(7);
             g.shoot();
          }
    }
    class Gun{
        
        //成员私有化后，使用范围就是当前的类 
        private int bulletnumber;
        //写的公共的方法对数据进行过滤
        public  void addbulletnumber(int number){
        
            if (number <0) {
        
            bulletnumber = 0;
            }else
            bulletnumber=number;
        }
        public void shoot(){
        
            if (bulletnumber > 0){
        
                System.out.println(--bulletnumber);
            }else
                System.out.println("你的枪里没有子弹");
        }
    }

### GetSet方法 ###

因为往往我们会有大量的属性需要进行赋值取值操作,所以就形成了一个规范
              赋值的规范:set
              构成:修饰词  返回值   方法名 (参数列表){
              		方法体中的代码
              		return 返回值
              }
              修饰词:一定是public
              返回值:不需要,这里写void
              方法名:set+属性的名字,名字的首字母大写
              参数列表:一般只有一个,写法:与属性同名
              代码:this.属性的名字 = 参数
              return:不需要
             
              取值的规范:get
              构成:修饰词  返回值   方法名 (参数列表){
              		方法体中的代码
              		return 返回值
              }
              修饰词:public
              返回值:类型与属性一致
              方法名:get+属性的名字,首字母大写
              参数列表:不需要
              代码:没有
              return 属性的名字/this.属性的名字

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbnl1YW5fOTg1_size_16_color_FFFFFF_t_70 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbnl1YW5fOTg1_size_16_color_FFFFFF_t_70 2]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbnl1YW5fOTg1_size_16_color_FFFFFF_t_70 3]

[20200714204439114.png]: https://img-blog.csdnimg.cn/20200714204439114.png
[20200714204418335.png]: /images/20230209/4ec5eab97ed54b168be43d2e80690386.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbnl1YW5fOTg1_size_16_color_FFFFFF_t_70]: /images/20230209/ada6b40f426448cc9a0e4bfb2c0fff75.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbnl1YW5fOTg1_size_16_color_FFFFFF_t_70 1]: /images/20230209/1e6cccb8ac7d47d3a8d25999dc23f15f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbnl1YW5fOTg1_size_16_color_FFFFFF_t_70 2]: /images/20230209/432cec10948b4ae196b4cb5ee8dd7c1f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbnl1YW5fOTg1_size_16_color_FFFFFF_t_70 3]: /images/20230209/ae30108e5bc34dcab407ac6ed4702981.png