1、类和类的实例化

目录

1、类和类的实例化

2、类的成员

2.2 方法

2.3 static关键字

3.封装

3.1 private实现封装

3.2 getter和setter方法

4.构造方法

4.1 基本语法

4.2 this关键字

 5. 认识代码块

5.1  什么是代码块

5.2  普通代码块

5.3  构造代码块

5.4  静态代码块

 6 、匿名对象

---

类是一类对象的统称。对象就是这一类的实例化。一个类可以产生无数个对象。

类中的元素称为成员属性，类中的方法称为成员方法。

a.任何一个源文件中有且只能有一个主类，并且源文件的名称需要和主类名称一致；

b.类的命名采用大驼峰命名法，所有单词的首字母大写，而变量的命名使用小驼峰命名法（第一个单词的首字母小写其他单词的首字母大写），常量的命名所有单词全部大写，多单词以_分割；

c.一个源文件中可以有若干个普通类（0...N)。

d定义一个类只是规定了一类对象所具备的属性和行为---模板，有了类，就可以根据类产生对象。

实例化对象的语法：<class_name>  <对象名>=new <class_name>;

new关键字用于创建一个对象的实例，

通过对象的引用访问使用对象中的属性和方法使用 “ . ”操作符。

class Person{
    public  int age; //成员属性
    public String name;
    public String sex;
    
    public void eat(){  //成员方法
        System.out.println("人吃饭");
    }
    
    public void sleep(){
        System.out.println("人睡觉");
    }
}

public class Test {
    public static void main(String[] args) {
        Person person=new Person();  //使用new实例化对象
        person.eat();  //成员方法调用通过对象的引用调用
        person.sleep();
        
        //一个类可以实例化多个对象
        Person person1=new Person();
        Person person2=new Person();
    }

}

2、类的成员

类的成员包含：成员变量、方法、代码块、内部类、接口等。

类中的成员变量（定义在类中的属性）与对象有关，当有对象产生时，才会开辟内存分配空间。

class Person{
    public  int age; //成员属性
    public String name;
}

public class Test {
    public static void main(String[] args) {
        Person person=new Person();
        System.out.println(person.age);
        System.out.println(person.name);
    }

}

 对于一个对象的成员变量如果没有显式设置初值，那么会被设置一个默认的初值。

默认值规则：

a.对于各种数字类型，默认值为0；

b.对于boolean类型，默认值为false；

c.对于引用数据类型（String，Array，以及自定义类），默认值为null。

但通常我们需要直接设定成员变量的初值：

class Person{
    public  int age=18; //成员属性
    public String name="张三";
}

public class Test {
    public static void main(String[] args) {
        Person person=new Person();
        System.out.println(person.age);
        System.out.println(person.name);
    }

}

//执行结果
18
张三

2.2 方法

class Person{
    public  int age=18; //成员属性
    public String name="张三";

    public void show(){
        System.out.println("我叫"+name +",今年"+age);
    }
}

public class Test {
    public static void main(String[] args) {
        Person person=new Person();
        person.show();
    }

}

//执行结果
我叫张三，今年18

此时的show方法与类实例化的对象相关联，如果创建了其他实例，那么结果就会发生改变。

class Person{
    public  int age=18; //成员属性
    public String name="张三";

    public void show(){
        System.out.println("我叫"+name +",今年"+age);
    }
}

public class Test {
    public static void main(String[] args) {
        Person person=new Person();
        Person person1=new Person();
        person1.age=22;
        person1.name="李四";
        person1.show();
    }

}
//执行结果
我叫李四，今年22

2.3 static关键字

static修饰的变量称为静态变量或类属性，静态变量和常量都存储在JVM的方法区上。

static可以修饰：

a.修饰属性

b.修饰方法

c.修饰代码块

d.修饰类（在内部类中）

a.修饰属性：Java中静态属性和类相关，和类的对象无关，同一个类的不同对象共用一个静态属性。

当一个类中的属性，该类的所有对象值都相同时，此时这个属性不在与具体的对象相关，而与所在的类相关。

访问静态变量，直接通过类访问，不推荐使用对象访问，static一定不可能出现在方法中，因为在方法中与对象强关联，有对象才能访问类的成员变量。

class TestDemo{
    public  int a;
    public  static int count;
}

public class Test {
    public static void main(String[] args) {
       TestDemo t1=new TestDemo();
       t1.a++;
       TestDemo.count++;
        System.out.println(t1.a);
        System.out.println(TestDemo.count);

        TestDemo t2=new TestDemo();
        t2.a++;
        TestDemo.count++;
        System.out.println(t2.a);
        System.out.println(TestDemo.count);
    }

}
//执行结果
1
1
1
2

3.封装

封装的本质就是让类的调用者不必太多的了解类的实现者时如何实现类的，只要知道是如何使用类的就可以了，这样就降低了类的使用者的使用成本，从而降低了复杂程度。

3.1 private实现封装

·  被public修饰的成员变量或者成员方法，可以直接被类的调用者使用。

·  被private修饰的成员变量或者成员方法，不能被类的调用者使用。

private不仅能修饰属性也属性可以修饰方法，当private修饰属性或方法时，这些属性和方法只能在这个类中使用。

3.2 getter和setter方法

当使用private来修饰成员变量时，就无法直接使用这个属性，需要用到getter和setter方法。

class Person{
    private   String name="xuexue";
    private   int age=20;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name; //this引用，表示调用该方法的对象
    }
}

public class Test {
    public static void main(String[] args) {
        Person person=new Person();
        person.setName("dongdong");
        String name=person.getName();
        System.out.println(name);
    }

}

getName即为getter方法，表示获取这个成员的值。

setName即为setter方法，表示设置、修改这个成员的值。

在setter方法中如果形参的名字和类中成员变量的属性名字一样时，如果不使用this，相当于自赋值，this表示当前对象的引用。

在IDEA中生成getter和setter方法的快捷键：alt+insert或alt+F12。

4.构造方法

4.1 基本语法

public 类名称（参数）{}；

使用关键字new产生新对象时会被自动调用，用于完成初始化操作。

new执行过程：

为对象分配内存空间

调用对象的构造方法

 语法规则：

1.构造方法的名称必须与类名称相同。

2.构造方法没有返回值类型声明。

3.每一个类中至少存在一个构造方法（如果没有明确定义，则系统自动生成一个无参构造）

4.如果类中没有提供任何的构造函数，那么编译器会默认生成一个不带参数的构造函数，若类中定义了构造函数，则默认的无参构造将不再生成。

5.构造方法支持重载，规则和普通方法重载一致。

class Person{
    private   String name;
    private   int age;
    private String sex;

    //构造方法
    public Person(){
        this.name="xuexue";
        this.age=20;
        this.sex="女";
    }

    public Person(String name,int age,String sex){
        this.name=name;
        this.age=age;
        this.sex=sex;
    }
    public void show(){
        System.out.println("name:"+ name +" age:" +age +" sex:" + sex);
    }
}

public class Test {
    public static void main(String[] args) {
        Person person=new Person(); //调用不带参数的构造方法
        person.show();
        Person person1=new Person("dongdong",19,"男"); //调用带有3个参数的构造方法
        person1.show();
    }


}

4.2 this关键字

this表示当前对象的引用（不是当前对象），可以用this来访问对象的属性和方法。

1.this修饰属性

this.属性名： 表示直接使用类中的成员变量。

2.this修饰方法

  2.1调用类中的成员方法：this.方法名

  2.2调用构造方法

  this（构造方法参数列表）

  a.当在构造方法中调用其他构造方法，该语句必须写在构造方法的首行。

  b.构造方法的调用不能成环。

class Person{
    private   String name;
    private   int age;
    private String sex;

    //构造方法
    public Person(){
        //this调用构造函数
        this("xuexue",20,"女");//必须放在首行
        System.out.println("helloworld");

    }

    public Person(String name,int age,String sex){
        this.name=name;
        this.age=age;
        this.sex=sex;
    }
    public void show(){
        System.out.println("name:"+ name +" age:" +age +" sex:" + sex);
    }
}

public class Test {
    public static void main(String[] args) {
        Person person=new Person(); //调用不带参数的构造方法
        person.show();
    }
}

 5. 认识代码块

变量的初始化方式有:

1.就地初始化

2.使用构造方法初始化

3.使用代码块初始化

5.1  什么是代码块

使用{} 定义的一段代码。

根据代码块定义的位置以及关键字，可以分为以下四种：

·  普通代码块

·  构造块

·  静态块

·  同步代码块

5.2  普通代码块

定义在方法中的代码块,出了代码块就会被销毁

public class Test {
    public static void main(String[] args) {
        {//直接使用{}定义
            int x=10;
            System.out.println("x1="+x);
        }
        int x=100;
        System.out.println("x2="+x);
    }
}
//执行结果
x1=10
x2=100

5.3  构造代码块

定义在类中的代码块，不加修饰符，一般用于初始化实例成员变量。

构造块优先于构造方法执行，有几个对象产生，构造块就执行几次。

class Person{
    private   String name;
    private   int age;
    private String sex;

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

    }

    //构造快
    {
        this.name="xuexue";
        this.age=20;
        this.sex="女";
        System.out.println("hellobit");
    }

    public void show(){
        System.out.println("name:"+ name +" age:" +age +" sex:" + sex);
    }
}

public class Test {
    public static void main(String[] args) {
        Person person=new Person(); //调用不带参数的构造方法
        person.show();
        Person person1=new Person();
        person1.show();
    }
}

5.4  静态代码块

使用static定义的代码块。一般用于初始化静态成员属性。

静态块在类加载（具体使用到某个类时，该类才会加载）时调用，只调用一次，因此不论有多少个对象，静态块只执行一次，并且优先于构造块执行，是最先执行的。

class Person{
    private   String name;
    private   int age;
    private String sex;
    private static int count=0;

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

    }

    //构造快
    {
        this.name="xuexue";
        this.age=20;
        this.sex="女";
        System.out.println("hellobit");
    }

    //静态块
    static {
        count=10;//只能访问静态成员变量
        System.out.println("hellostatic");
    }

    public void show(){
        System.out.println("name:"+ name +" age:" +age +" sex:" + sex);
    }
}

public class Test {
    public static void main(String[] args) {
        Person person=new Person(); //调用不带参数的构造方法
        person.show();
        System.out.println();
        Person person1=new Person();
        person1.show();
    }
}

 6 、匿名对象

匿名对象就是没有名字的对象

·  没有引用的对象称为匿名对象。

·  匿名对象只能在创建对象的时候使用。

·  如果一个对象只是用一次，后面不需要用了，可以考虑使用匿名对象，用完会被JVM销     毁 。                               

class Person{
    private   String name;
    private   int age;
    private String sex;
    private static int count=0;

    //构造方法
    public Person(String name,int age,String sex){
        this.name=name;
        this.age=age;
        this.sex=sex;
    }

    public void show(){
        System.out.println("name:"+ name +" age:" +age +" sex:" + sex);
    }
}

public class Test {
    public static void main(String[] args) {
      new Person("雪雪",20,"女").show();
    }
}
//执行结果
name：xuexue age: 20 sex: 女