Java中的类和对象

类和对象

1.类和对象的认识

在Java中一些皆对象，Java是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象和对象之间的交互完成

把具有相同属性和行为的一类对象抽象为类，使用类来描述这类对象的特征

2.类和类的实例化

类是描述一些对象的统称，对象是这个类中的一个实例，这一类对象所具备的共同属性和行为（方法）都在类中定义

//创建类
class <class_name>{
    filed;//成员属性
    method;//成员方法
        }
​
//实例化对象
<class_name> <对象名> = new <class_name>();

class就是定义类的关键字，类中的元素成为成员属性，类中的方法成为成员方法

定义一个Person类

class Persoon {
    String name;
    int age;
    String sex; 
    void eat(){
        System.out.println("吃饭");
    }
    void sleep(){
        System.out.println("睡觉");
    }
}

注意：类的命名使用大驼峰命名法

类中定义的成员变量都有默认值，默认值就是这个变量所在类的默认值

类的实例化

有了类以后，就可以根据类来产生一个实例化对象

类名称 引用名称 = new 类名称();

产生了类的对象后，就可以使用"."操作符来使用该类的属性和方法

class Persoon {
    String name;
    int age;
    String sex;
    void eat(){
        System.out.println("吃饭");
    }
    void sleep(){
        System.out.println("睡觉");
    }
​
    public static void main(String[] args) {
        Persoon persoon = new Persoon();
        persoon.eat();
        persoon.sleep();
    }
}

3.static关键字

static与对象无关

 修饰属性

static修饰的属性为静态属性，所有对象共享

当一个实例变量被static关键词修饰，就表示类的属性，该属性在JVM的方法区中储存，该类的所有对象共享，所有对象的属性值也都一样

public class TestDemo {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.name = "张三";
        p1.age = 18;
        Person p2 = new Person();
        p2.name = "李四";
        p2.age = 19;
        System.out.println("p1的name = " + p1.name + "，p1的age = " + p1.age + "，p1的city = " + p1.city);
        System.out.println("p2的name = " + p2.name + "，p2的age = " + p2.age + "，p2的city = " + p2.city);
        //输出结果： p1的name = 张三，p1的age = 18，p1的city = 西安
        //         p2的name = 李四，p2的age = 19，p2的city = 西安
    }
}
​
class Person{
    String name;
    int age;
    static String city = "西安";
}

 方法内部不能定义static变量：局部变量保存在栈中，静态变量保存在方法区中，局部变量出了方法就会被栈回收，静态变量不会

常量：在类中定义常量，一般会使用全局常量，用static和final共同修饰。命名规则为：所有单词大写，单词之间用下划线分割

修饰方法

4.构造方法

构造方法是一种特殊的方法，使用关键字new实例化对象的时会自动被调用，构造方法的作用就是产生对象

使用new关键字产生一个对象时大致分为两步

a.为对象分配内存空间

b.调用对象的构造方法

语法规则：

a.方法名与类名相同

b.构造方法没有返回值声明

c.一个类中至少存在一个构造方法，若没有显示定义，编译器会生成一个默认的无参构造

public class TestDemo {
    public static void main(String[] args) {
        Person p = new Person();
    }
}
​
class Person{
    String name;
    int age;
    public Person(){
        System.out.println("Person的构造方法");
    }
}

构造方法可以重载

public class TestDemo {
    public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person("张三");
        Person p3 = new Person("李四",18);
        
    }
}
​
class Person{
    String name;
    int age;
    public Person(){
        System.out.println("Person的构造方法");
    }
    public Person(String n){
        name = n;
        System.out.println("name = " + name);
        System.out.println("Person的一个参数的有参构造");
    }
    public Person(String n,int a){
        name = n;
        age = a;
        System.out.println("name = " + name + ",age = " + age);
        System.out.println("Person的两个参数的有参构造");
    }
}
//输出结果：Person的构造方法
//name = 张三
//Person的一个参数的有参构造
//name = 李四,age = 18
//Person的两个参数的有参构造

5.this关键字

this表示当前对象的引用

1.调用当前对象的成员变量

public class TestDemo {
    public static void main(String[] args) {
        Student student = new Student("张三",18,"男");
        student.shou();
    }
}
​
class Student{
    String name;
    int age;
    String sex;
​
    public Student(String name,int age,String sex) {
        name = name;
        age = age;
        sex = sex;
        System.out.println("Student类的有参构造");
    }
​
    public void shou(){
        System.out.println("name = " + name + ",age = " + age + ",sex = " + sex);
    }
}

 程序设计的理念，就近匹配原则，会找最近的相同名称变量

public class TestDemo {
    public static void main(String[] args) {
        Student student = new Student("张三",18,"男");
        student.shou();
    }
}
​
class Student{
    String name;
    int age;
    String sex;
​
    public Student(String name,int age,String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        System.out.println("Student类的有参构造");
    }
​
    public void shou(){
        System.out.println("name = " + name + ",age = " + age + ",sex = " + sex);
    }
}

6.代码块

1.普通代码块（定义在方法中的）直接用{}定义

public class TestDemo {
    public static void main(String[] args) {
        {
            int x1 = 10;
            System.out.println("x1 = " + x1);
        }
        int x2 = 20;
        System.out.println("x2 = " + x2);
    }
}

2.构造块

直接定义在类中，不加任何修饰符，优于构造方法执行，有几个对象产生就调用几次构造块

public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        Person person1 = new Person();
    }
}
​
class Person{
    String name;
    {
        System.out.println("1.Person的构造块");
    }
    public Person(){
        System.out.println("2.Person的无参构造");
    }
}

 3.静态代码块

定义在类中，使用static关键词修饰，在类加载时执行一次

public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();
        Person person1 = new Person("张三");
    }
}
​
class Person{
    String name;
    {
        System.out.println("1.Person的构造块");
    }
    public Person(){
        System.out.println("2.Person的无参构造");
    }
    public Person(String name){
        this.name = name;
        System.out.println("2.Person的有参构造");
    }
    static {
        System.out.println("3.Person的静态代码块");
    }
}