泡泡冷知识 类和对象2

类和对象2

1、回顾上节

什么是面向对象？
一种叫面向过程，面向过程就是直接按逻辑来
一种叫面向对象，面向对象就是先抽象为对象再执行逻辑。

1.1、this用法

this:
this.data //访问成员变量
this.fun() //访问成员方法
this() //调用构造函数

以下示例：

class Person{
    public String name;
    public int age;

    //在一个构造方法中  可以去调用另外一个构造方法
    //这时候先打印带两个参数的 后打印不带参数的  注意：不能成环   而且只能放在第一行
    public Person(){
        this("zhenzhen",99);
        System.out.println("不带参数的构造方法");

    }

    /**
     * 构造方法          可以发生重载
     * @param name
     * @param age
     */
    public Person(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("带有两个参数的构造方法");
    }
    public void sleep(){
        int a = 0;
        System.out.println(a);
        //谁调用sleep谁就是this  : this 代表当前对象的引用  person2
        System.out.println(this.name + "正在吃饭！");

    }
    public void eat(){
        this.sleep();
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class TestDemo {

    public static void main(String[] args) {
        //Person person1 = new Person();
        System.out.println(new Person());
        //跟上面一个效果
        /*System.out.println("================================");
        Person person2 = new Person();
        System.out.println("================================");
        Person person3 = new Person("weiwei",98);*/
    }

    public static void main1(String[] args) {
        Person person1 = new Person();//Person()就是调用不带参数的构造方法
        person1.name = "a wei";
        person1.sleep();

        Person person2 = new Person();//Person()就是调用不带参数的构造方法
        person2.name = "zhenzhen";
        person2.sleep();

    }
}

2、static成员

2.1、学生类演示

实例化对象：

        Student student1 = new Student("bit",18,34.6);
        Student student2 = new Student("张三",28,14.6);

共有全部属性，如图：

没有加入 static 测试显示上面 class

这里第五行加入 static 之后 测试并没有 classes
这时候分析一下 static 修饰静态成员变量

class Student{

    private String name;
    private int age;
    private double score;
    private static String classes;

    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public void doClsaa(){
        System.out.println(this.name+ " 正在上课！");
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
}



public class TestDemo {
    public static void main(String[] args) {
        Student student1 = new Student("bit",18,34.6);

        Student student2 = new Student("张三",28,14.6);

        System.out.println("hello");
    }
}

这里加入代码：

public static String classes;//  加入为第五行

//这里直接通过类名访问
Student.classes = “11Java”;

2.2、static修饰静态成员变量

static修饰的成员变量，称为静态成员变量，静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共 享的。

插入代码：

public static void main(String[] args) {

        Student student1 = null;

        Student.classes = "104Java";

        System.out.println(Student.classes);
}

运行后：

表明：
第一行代码Student1不指向任何对象 classes不属于任何对象
静态的成员变量和静态的成员方法都不依赖于对象，因为他们是类变量.

在普通方法去也可以使用静态成员变量

public static void main(String[] args) {
        Student.classes = "104Java";
        Student student1 = new Student("bit",18,34.6);
        student1.doClass();
    }

运行结果：

但是在静态成员变量中不能访问非静态的成员 （成员变量和成员方法）
非静态的成员变量是依赖于对象的

【静态成员变量特性】

1. 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中
2. 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问
3. JDK7及以前，HotSpot(Java虚拟机)中存储在方法区，JDK8及之后，类变量存储在Java堆中
4. 类变量存储在方法区当中
5. 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)

3、代码块

3.1、什么是代码块及分类

使用 {} 定义的一段代码称为代码块。根据代码块定义的位置以及关键字，又可分为以下
普通代码块、构造（实例代码）块、静态块

3.2、实例代码块

代码演示：

{
        this.name = "haha";
        this.age = 19;
        this.score = 88;
        System.out.println("实例代码块！一般用来初始化实例普通成员变量成员");
    }

【注意事项 】

实例代码块优先于构造方法执行，因为编译完成后，编译器会将实例代码块中的代码拷贝到每个构造方法第一条语 句前。

3.3、静态代码块

使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量。

注意事项

静态代码块不管生成多少个对象，其只会执行一次
静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的
Java代码在经过编译器编译之后，如果要运行必须先要经过类加载子系统加载到JVM中才能运行。
如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次合并，最终放在生成的<>方法中，该方法在类加载时调用，并且只调用一次。

代码演示：

public static void main(String[] args) {
        /**
         * 1、调用带有三个参数的构造方法
         */
        Student student1 = new Student("bit",18,34.6);
        //System.out.println(student1);
        System.out.println("====================================");
        Student student2 = new Student("张三",28,14.6);
    }

运行结果：