Java面向对象(2)，构造器，static和块

​
首先让我们来认识一下什么是面向对象，面向对象其实就是一种处理问题的思维，

就好比去接杯茶这件事；

​
有两种思维，一种是面向对象，一种是面向过程；

​ 面向过程：接杯茶之间的流程是什么，如何做这件事，是不是要先拿起水杯，泡上茶叶，然后走向饮水机，然后接杯热茶；它是针对一件事，注重的是实行过程。

​ 面向对象：在这里我们就不管接杯茶这个事有哪些步骤，而只管接了杯茶，不管过程，我们可以喊小王帮忙接杯茶，只需要面对小王指定这件事就可以了，注重的是结果。

在面向对象中，整个程序的基本单位是类，方法是从属于类的；类与对象的关系是特殊到一般，从具体到抽象

​
类：我们叫做class

​ 对象：我们叫做object，instance (实例)

​ 关系：某个类的对象，某个类的实例

接着上一章讲

1.一个类的基本组成

​

(1)属性：

成员变量

​ (2)方法

​ ---------------------------上一章内容

重点 ： (3)构造器（构造方法）： Constructor 其实也是一种特殊的方法

​ 定义：初始化对象信息,不是用来创建对象的

​ 使用：跟随new一起使用

​ 结构：修饰符 类名(参数列表){

​ 方法体；

​ }

​ 特点：1.构造器也是特殊的方法,定义多个重载构造器,构造器的名字都与类名保持一致,参数列表不同就能构成重载构造器

​ 2.如果没有显示的定义构造器,编译器会自动为类提供一个空构造

​ 3.如果存在显示定义的构造器,编译器不会提供任意构造器

	不需要返回值类型,也没有void
    可以根据需要定义return关键字,作用提前结束方法
    构造器的名字与类名保持一致

 注意:
        1.构造器可以实现重载,因为是特殊的方法
        2.没有显示定义构造器,编译器会默认提供空构造
        3.如果存在显示 定义构造器,不会提供任何构造器,包括空构造
        4.至少提供一个空构造...按需提供带参,不绝对,根据需求决定

public class Class001_Constructor {
    public static void main(String[] args) {
        //先成员对象
        Dog dog = new Dog();
        //new Dog();
        //为对象的成员赋值
        //dog.name = "";
        //dog.type = "";

        dog.lookDoor();

        //创建对象的同时赋值
        new Dog("馒头").lookDoor();

        new Dog("麻团","中华田园犬","斑点").lookDoor();
    }
}


class Dog{
    public String name;
    public String type;
    public String color;

    //空构造: 没有参数的构造器
    public Dog(){
        System.out.println("空构造");
    }

    public Dog(String dogName){
        System.out.println("一个参数构造");
        //把实参接收到的数据赋值给了当前对象的成员变量name
        name = dogName;
    }

    public Dog(String dogName,String dogType,String dogColor){
        System.out.println("三个参数构造");
        //把实参接收到的数据赋值给了当前对象的成员变量name
        name = dogName;
        type = dogType;
        color = dogColor;
    }

    public void lookDoor(){
        System.out.println(name+"正在看家....");
    }
}

​ (4)代码块 block

​ 局部代码块： {}定义在方法中 跟随方法的调用而执行

​ 1) 作用域看待

​ 2) 语义化

​ 构造块：{}定义在类中方法外 跟随new一起使用

​ 1) 成员内容的初始信息,比构造器中的代码跟早执行

​ 2) 对对象的某些内容进行初始

​ 静态块： static修饰{},定义在类中方法外 在类第一次加载完成之后执行

​ 1) 会为静态内容进行初始化

​ 2) 信息的配置,资源的加载

​ 同步块（不多讲）

public class Class001_Block {
    static int i ;
    int j = 1;

    public Class001_Block(){
        System.out.println("构造器");
    }

    //构造块
    {
        System.out.println("构造块1");
        System.out.println(i);
        System.out.println(this.j);  //当前new的对象
    }
    {
        System.out.println("构造块2");
    }
    {
        System.out.println("构造块3");
    }

    //静态块
    static{
        System.out.println("静态块1");
        System.out.println(i);
        //非静态的成员变量j不能直接在静态内容中使用,需要跟随对象
        //System.out.println(j);
    }
    static{
        System.out.println("静态块2");
        i = 1000;
    }
    static{
        System.out.println("静态块3");
    }


    public static void main(String[] args) {
        System.out.println("main");
        //局部
        //int i =1;

        //局部代码块
        {
            int i = 10;
            System.out.println(i);
        }
        System.out.println(i);

        new Class001_Block();
    }
}

​ (5)内部类（先不深入）

2.this关键字（重点）

​ 指代当前对象(new的对象)–>存储所有指向的对象的地址

构造器的首行调用本类中的其他构造器
this(参数列表)

    区分同名的成员与局部的问题
        默认就近原则
        如果出现同名问题,想要指代调用成员,通过this.成员-->因为this指代对象,通过对象调用成员
        如果没有同名问题,可以省略this.调用成员
        在构造器中使用this,默认指代当前new的对象,存储的是this的对象的地址
        在的成员方法中使用this,this在成员方法中默认指代当前调用成员方法的对象

    注意:
        1.多个构造器之间不能相互调用,否则无法停止调用
        2.在static修饰的内容中不能使用this

public class Class001_This {
    public static void main(String[] args) {
        Dog dog = new Dog("斑点波比","萨摩耶","白色");
        dog.show();

        Dog dog2 = new Dog("小白");
        dog2.show();
        System.out.println("dog2的地址"+dog2);
    }
}

class Dog{
    public String name;
    public String type;
    public String color;

    //构造器
    public Dog(){
        System.out.println("空构造");
    }

    public Dog(String name){
        System.out.println("一个参数构造");
        this.name = name;
        System.out.println("this地址" + this);
    }

    public Dog(String name,String type){
        System.out.println("二个参数构造");
        this.name = name;
        this.type = type;
    }

    public Dog(String dogName,String dogType,String dogColor){
        this(dogName,dogType);
        color = dogColor;
        System.out.println("三个参数构造");
    }

    public void lookDoor(){
        System.out.println(name+"正在看家....");
    }
    public void show(){
        String name = "局部的name值";
        //this在成员方法中默认指代当前调用成员方法的对象
        System.out.println(this.name+"-->"+type+"-->"+color);
    }
}

3.static关键字（次重点）

​ 1.在静态内容中,可以直接使用静态的内容,需要跟随对象使用成员
​ 2.在成员内容中,可以直接 使用静态内容,可以直接 使用成员内容

this不能使用在静态环境中,静态的方法可以直接跟随类调用,可以能根本不存在对象,静态方法的this,无法指代某个对象

public class Class002_Static {
    //成员位置: 类中方法外
    //实例变量
    int i = 1;
    //静态变量
    static int j = 2;

    public static void main(String[] args) {
        System.out.println(j);
        Class002_Static cs  = new Class002_Static();
        System.out.println(cs.i);

        cs.test();
        testStatic();
    }

    //成员方法中,this默认指代调用成员方法的对象
    public void test(){
        System.out.println("成员方法");
        System.out.println(j);
        System.out.println(this.i);
    }

    public static void testStatic(){
        System.out.println("静态方法");
    }
}

经典混合例题

package com.yjx.block03;
//找到打印顺序+结果
public class Class002_BlockTest {
	public static int a = 0;

	static {
		a = 6;
		System.out.println(" 、静态代码块执行a=" + a); //
	}
	public Class002_BlockTest() {
		this(a); //
		System.out.println(" 、"+a);  //
		System.out.println(" 、无参构造方法执行a=" + a); //
	}
	public Class002_BlockTest(int n) { //n=
		{
			a = 10;
			System.out.println(" 、非静态代码块执行a=" + a); //
		}
		System.out.println(" 、"+n); //
		System.out.println(" 、"+a);//
	}	
	public static void main(String[] args) {
		System.out.println(" 、main"); //
		Class002_BlockTest tsc = new Class002_BlockTest();
	}
}

4.debug代码调试工具（重点）

代码调试工具，这里就不多讲了，可以去百度上搜一搜哦