面向对象的介绍2

了解block块：

{} 块自成作用域：

    分类

局部代码块|普通代码块：1.定义在方法中

1）.作用域看待

2）.语义化：看见这个{}就知道范围，以及作用域

构造块：{} 定义在类中方法外

1）.成员内容的初始信息，比构造器中的代码更早执行

2）.对对象的某些内容进行初始化

静态块：static修饰的{} ，定义在类中方法外----也就main外到class之间的

1）.会为静态内容进行初始化

2）.信息的配置，资源的加载

同步块：多线程学习： Java 同步块（synchronized block）用来标记方法或者代码块是同步的。Java 同步块用来避免竞争

/*

• Java 同步关键字（synchronzied）
• 实例方法同步
• 静态方法同步
• 实例方法中同步块
• 静态方法中同步块
• Java 同步示例

*/

实例方法同步：

public synchronized void add(int value){

this.count += value;

}

静态方法同步:

public static synchronized void add(int value){

count += value;

}

实例方法中的同步块

public void add(int value){

synchronized(this){

this.count += value;

}

}

静态方法中的同步块：

public class MyClass {

public static synchronized void log1(String msg1, String msg2){

log.writeln(msg1);

log.writeln(msg2);

}

public static void log2(String msg1, String msg2){

synchronized(MyClass.class){

log.writeln(msg1);

log.writeln(msg2);

}

}

}

构造块中的代码会先于构造器中的代码之前执行

如果存在多个构造块，会从上到下依次执行

静态块在类的第一次加载完成之后会执行，并且会执行一次

执行的顺序：静态块-->main-->创建对象-->构造块-->构造器

{//不在main中，但是在类中

        System.out.println("构造块1");

        System.out.println(i);

        System.out.println(this.j);  //当前new的对象

    }

//静态块

    static{//拥有static

        System.out.println("静态块1");

        System.out.println(i);

        //非静态的成员变量j不能直接在静态内容中使用,需要跟随对象

        //System.out.println(j);

    }

//局部代码块

        {//在main中的代码块

            int i = 10;

            System.out.println(i);

        }

this关键字：

指代当前对象（new的对象）-->存储所有指向的对象的地址

构造器的首行调用本类中的其他构造器

this（参数列表）

区分同名的成员与局部的问题

默认就近原则（谁近选择谁）

如果出现同名问题，想要指代调用成员，通过this.成员-->因为this指代对象

，通过对象调用成员

如果没有同名问题，可以省略this。调用成员

在构造器中使用this，默认指代当前new的对象，存储的是this的对象的地址

在的成员方法中使用this，this在成员方法中默认指代当前调用成员方法的独享

注意：

1.多个构造器之间不能相互调用，否则无法停止调用

2.在static修饰的内容中不能使用static

//例子

  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);

    }

static 静态的

        成员修饰符 : 只能修饰成员位置的内容,不能修饰局部

        修饰变量 : 静态变量|类变量

        修饰方法 : 静态方法|类方法

        修饰块 : 静态块

        修饰类 : 静态内部类

//成员位置：成员变量和成员方法

        静态内容的使用:

                    1.跟随类名使用

                        类名.静态变量名

                        类名.静态方法名(参数列表);

                    2.跟随对象使用

                        引用.静态变量名

                        引用.静态方法名(参数列表);

        成员是是属于对象的

        静态的是属于类的

        成员变量 :

            被static修饰的变量 --> 静态变量|类变量

            不被static修饰的变量 --> 实例变量

        成员方法:

            被static修饰的方法 --> 静态方法|类方法

            不被static修饰的方法 --> 实例方法

        注意:

            this只能使用在非静态环境中

            在非静态方法中使用this,默认指代当前调用实例方法的对象

            静态内容是独一份的,静态变量存在与静态区中,多个对象共享的资源

            成员内容跟随对象存在与对象的堆内存中,多个对象,就有多份成员

            初始加载顺序: 先静态后成员

            静态内容在类第一次加载完成之后就会进行初始化

            成员变量必须在执行到new对象的时候,才会存在对象的堆内存,在对象的堆内存中才会有成员变量

*/

//例子

//成员位置: 类中方法外

    //实例变量

    int i = 1;

    //静态变量

    static int j = 2;

    //静态方法

    public static void main(String[] args) {

        //测试静态内容使用方式

        System.out.println(j); //本类中可以省略类名直接使用

        System.out.println(Class001_Static.j);

        Class001_Static cs = new Class001_Static();

        Class001_Static cs2 = new Class001_Static();

        System.out.println(cs.j);

        //测试实例变量的使用

        System.out.println(cs.i);

        //System.out.println(Class001_Static.i);

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

    2.在成员内容中,可以直接 使用静态内容,可以直接 使用成员内容

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