JavaBasic_08

类的定义

       [修饰符]  calss 类名 [extends 父类名]

                        [implements 接口名]
         {
                           [成员变量声明;]
                           [成员方法声明;]
         }
    

注：[]里面的东西不是必须的。

同一个java文件中，可以定义多个类，只能有一个被public修饰的类，而且public类的类名必须和java文件

类体有两部分构成：

一为成员变量定义（域） Field

二为成员方法定义

---

创建对象

步骤1——声明一个对象（引用变量）

ClassName identifier;

例：Student s

引用变量：引用变量存储的地址

步骤2——初始化

identifier = new ClassName();

例：s = new Student();

或者声明和初始化同时进行

例：Student s = new Student();

如何通过类来创建对象呢？

第一步：声明对象的引用变量

第二步：初始化这个对象的引用变量

如何访问对象中的成员变量和成员方法呢？

• 如果我们把对象的引用变量看成对象的名字的话
  对象名(对象的引用变量).成员变量
  对象名(对象的引用变量).成员方法

步骤3——赋初值

通过访问对象的成员变量，来修改成员变量的值

//数组的静态初始化，数组中的元素的初值，就成了我们想要的值，而不是系统的默认值
    数组类型[] 数组名 = {数值1， 数值2，.....}

在对象中也可以实现类似的效果：对象成员变量可以被初始化我们想要的值，而不是系统的默认值。

数组的静态初始化:经过静态初始化，数组中的的元素的初值，就变成了我们想要的值，而不是系统的默认值
数据类型[] 数组名 = {数值1，初值2,...}；

---

构造方法

构造方法作用概述

给对象的数据进行初始化（可以初始化我们想要的值）

构造方法格式

1.方法名和类型相同

2.没有返回值类型，连void都没有

3.没有具体的返回值

注意事项：

1.构造方法，不是由我们来调用的，是由我们的jvm在构造对象的时候来调用

2.当构造方法执行完毕之后，我们才说对象构造完毕

3.如果你不提供构造方法，系统会给出默认构造方法，如果你提供构造方法，系统将不再提供默认的构造方法。

==构造方法不属于成员变量，也不属于成员方法。==

默认构造方法长啥样？

    public Student2(){

    }

构造方法有栈帧和它对应，但是，在真正执行的时候，执行的是JAVM的

我们之前讲过，如何访问对象中的成员变量和方法？

对象名.

如果在类体中，我们要访问成员变量方法和成员方法不需要对象名.的形式来访问本类中的成员变量和成员方法：

直接用成员变量的变量名和成员变量的方法

import java.util.ArrayList;

public class Construtor {

    public static void main(String[] args) {
        //如何给构造方法传递实际参数的值
        //在 new对象的时候，类名之后的（），就相当于是构造方法的实际参数的参数列表，简单来讲，
        // 通过类名之后()，来给构造方法，传递初始化的实际参数值
        // 我们可以把)，new com.cskaoyan.objects.Student2(; 看成是对构造方法的调用
        Student2 student2 = new Student2(18);
        student2 = new Student2(28, "李四", 004);
        System.out.println(student2.age + "  " + student2.id + " " + student2.name);
    }

}

class Student2 {

    int id;
    String name;
    int age;

    //默认构造方法
    public Student2() { }

    public Student2(int sid) {
        id = sid;
    }

    public Student2(String n, int a) {
        name = n;
        age = a;

    }

    public Student2(int sid, String n, int a) {
        id = sid;
        name = n;
        age = a;
    }

    public void eat(String food) {
        System.out.println("eat " + food);
        sleep();
    }

    public void sleep() {
        System.out.println("睡觉");
    }

    public void study() {

        System.out.println("我爱学习");
    }
}

---

成员变量初始化：成员变量，都在堆上，堆中的东西天然有初值（jvm会对成员变量做默认初始化 ）

局部变量：

1.在一个方法（1.参数列表里）或者方法里面的2.代码块中定义的变量称为局部变量

2.在方法执行是创建变量空间（栈帧），在方法结束之后，空间立马被销毁（回收）

3.局部变量必须先赋值再使用，否则会出现编译错误。

先赋值:jvm不会帮我们对局部变量做默认初始化，只能我们程序员通过赋值语句初始化

变量的作用域：变量的使用范围

假定在某代码段中能够使用一特定变量，则此段代码即是该变量的作用域。

作用域，就是变量所在的那一对{}范围

对于局部变量：

在有交集的作用域中，不能定义重名变量

成员变量的隐藏：

1.成员变量的名字和局部变量的名称相同（编译器所允许，从内存的角度理解，一个在堆空间，一个在栈空间）

2.当在同名局部变量所在的作用域中通过变量名，来访问成员变量，此时是访问不到成员变量，只能访问到局部变量的值。

通过引入this关键字，来解决成员变量的隐藏问题。

this:

1.表示当前对象

之前讲过，访问对象的成员变量和成员方法的呢？

• 对象名.成员变量
• 对象名.成员方法的方式

当你在访问对象的成员变量和成员方法的时候， 中的对象就是this（即当前对象）

2.可以通过this来调用构造方法

==1.this对调用构造方法的代码，必须位于构造方法的方法体中，同时必须是构造方法的第一句代码。==

/*
练习：
（1）创建一个带默认构造函数的类。在该默认构造函数中打印一条消息。然后为这个类创建一个对象，观察默认构造器的调用。

（2）继续为这个类添加一个重载构造函数——一个带参数的构造函数，令其接受一个字符串作为参数，
并在该函数内将这个字符串参数输出在原来构造函数打印出的字符串之后。

（3）继续为这个类添加两个构造函数，让两个构造函数都接收两个类型不同的参数，但是这两个参数的顺序相反，
验证这两个构造函数是否可以正常工作。

（4）在这有两个参数的构造函数中，能否调用之前写的一个参数的构造函数？如何调用？
答：使用this

 */
public class HomeWork02 {

    public static void main(String[] args) {
        HomeWork02 homework1 = new HomeWork02();
        HomeWork02 homework2 = new HomeWork02("String:HomeWork02");
        HomeWork02 homework3 = new HomeWork02(1, "wangdao01");
        HomeWork02 homework4 = new HomeWork02("wangdao02", 2);
    }

    //构造方法
    public HomeWork02(){
        System.out.println("HomeWork02");

    }

    public HomeWork02(String str){
        System.out.println(str);
    }

    public HomeWork02(int n, String str){
        this();
        System.out.println(n + " " + str);
    }

    public HomeWork02(String str, int n){
        this("wangdao03");
        System.out.println(str + " " + n);
    }
}

2.this如果构造方法存在重载，如何调用重载的构造方法呢？只要this()实际参数列表和相应重载的构造方法一致即可。

public class Initialize {

    public static void main(String[] args) {
        Person person = new Person(10);

        //person.shout();
        System.out.println(person.age);
    }
}

class Person
{
    //成员变量
    //成员变量的作用域是整个类体
    int age;

    int id;

    public Person(int age) {
        //通过this关键字告诉jvm，this.age指的成员变量而不是局部变量

        System.out.println("age = " + age);

    }

    public Person(int age ,int id) {

        //通过this来调用我们自己写的构造方法代码
        this(age);
        this.id = id;
    }

    //一旦添加了返回值类型，它就变成了普通方法
//    public void Person(int a) {
//        age  = a;
//    }
    void shout()

    {
        //this(10);
        //局部变量
        //i的作用域是整个方法体
        int  i = 100;
        int age = 0;
        this.age = age;

        {
            //在嵌套的作用域中，也不能定义同名的变量
            //int i= 0;

            // j的
            int j = 100;

        }
        //System.out.println(j);

        {
            //在两个完全没有交集的作用域中，可以定义同名 变量
            int j = 100;
        }

        for(int k = 0; k < 10; k++) {

        }
        //System.out.println(k);

        System.out.println("oh,my god! I am " + age + " " + i);

        //Person(10);

    }
}

---

Static关键字

static是一个修饰符，被static修饰的成员有何特征？

static关键字特点

1.随着类的加载而加载(被static修饰符修饰的成员，变量或者方法何时分配内存来存储)

2.优先于对象存在（时间，是在类加载的时候进入内存） 不依赖对象而存在，依赖于类而存在

3.被类的所有对象共享

被static修饰的成员变量或者成员方法，又有一个名字：类变量或者类方法

访问static修饰成员变量或方法：我们可以通过 类名.成员变量

                                        类名.成员方法

这也是我们判断是否使用静态关键字的条件

可以通过类名调用（建议只用类名调用）

因为普通成员变量或成员方法，依赖于对象而存在，而我们的静态的成员方法，是先于对象而存在（不依赖于对象），而存在，如果在静态的成员方法中可以访问普通成员变量，就会产生一个问题：

1.当方法区中夹杂了，类的字节码文件内容，在加载的同时，该类的静态的成员变量和成员方法也会进入方法区中

2.此时，在堆内存中有可能，还不存在任何一个该类的对象，因此在静态方法中也就访问不到对象的成员变量

3.而且，static可以通过类名去StaticVariable.test()

static关键字注意事项

1.在静态方法中是不可以使用this关键字的

2.静态方法只能访问静态的成员变量和静态的成员方法，也就是说在静态方法内无法访问非静态方法（非静态的成员变量和非静态的成员方法）。

注意

//在Java中规定不能讲方法体内的局部变量声明为static的。例如下述代码就是错误的

public class example{
    public void method(){
        static int i =0;
    }
}

技巧

//如果在执行类时，希望先执行类的初始化动作，可以使用static定义一个静态区域。例如：
public class example{
    static{
        //some
    }
}
//当这段代码被执行时，首先执行static块中的程序，并且只会执行一次。

静态变量和成员变量的区别

1.所属不同

静态变量属于类，所以也称为类变量

成员变量属于对象，所以也称为实例变量（对象变量）

2.内存中位置不同

静态变量存储于方法区的静态区

成员变量存储于堆内存

3.内存出现时间不同

静态变量随着类的加载而加载，随着类的消失而消失（类卸载）

成员变量随着对象的创建而存在，随着对象的消失而消失

4.调用不同

静态变量可以通过类名调用，也可以通过对象调用      类名. 对象.

成员变量只能通过对象名调用   对象名.

---

代码块

1.在Java中，使用{}括起来的代码被称为代码块，

2.根据其位置和声明的不同，可以分为

局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。     

局部代码块

在方法中出现；限定变量生命周期，及早释放，提高内存利用率

构造代码块(每次创建对象的时候都会执行)

1.在类中方法外执行

2.在构造对象时执行，并在构造方法前执行

静态代码块（只随着类的加载，而执行一次）

1.静态代码块，在类中方法外出现

2.加了static修饰

随着类加载而执行（同一类来讲，jvm只会加载一次，所以静态代码块也只会执行一次）

同步代码块（多线程才有的）：

public class JavaBlock {
    public static void main(String[] args) {
        BlockTest blockTest = new BlockTest();
        BlockTest blockTest1 = new BlockTest();
    }
}

class BlockTest {

    //构造代码块的代码，在构造对象的时候都必须执行
    int i;
    {
        // 构造代码块，也可以用来做一些初始化动作
        System.out.println(" initialize  block");

        //如果说每个构造方法中重复代码(保证不管使用哪个构造方法初始化对象，都会执行这段代码)，但是如果
        //这些代码放在构造代码块中，那么只需要一份就可以，因为构造代码块中的代码在构造对象时一定执行
    }

    //静态代码块
    static {
        System.out.println("static block");
    }

    public BlockTest( ) {
        System.out.println("BlockTest");
        //假设在无参构造方法中每次创建对象时，都要执行一些代码
    }

    public BlockTest(int i) {
        //假设在1参构造方法中每次创建对象时，也要都要执行一些和无参构造相同的代码
    }

    public void  tesetLocalBlock()
    {
        //局部代码块
        {
            int i = 100;
            System.out.println(i*i);

        }
    }
}

---

修饰符

我们可以通过访问控制修饰符（access modifiers）可以限制  成员变量  在类或对象外部的可见性

public ——共有的，域在任何地方都可以访问

private —— 私有的，域仅在类体中访问

    1.只有同一类中创建的对象才能访问私有域

    2.在其他类中创建的对象不能访问私有域

default（不写）——默认的package，没有任何访问修饰符修饰的域，仅在类体中、同包的其他类类体中可访问

protected——受保护的，仅在类体中、子类类体中或同包的其他类体中可访问

在类体被申明为保护的域可以被同一个包中的该类的对象访问。也能被其他子类访问，而不管它们是否在

类前也可以加修饰符：

**但是对于普通类来讲，只可以使用两种修饰符**

1.public

2.不写权限修饰符