关于java:类和对象

5次阅读

共计 7160 个字符，预计需要花费 18 分钟才能阅读完成。

客观存在的事物皆为对象，所以咱们也经常说万物皆对象。

类
- 类的了解
  - 类是对现实生活中一类具备独特属性和行为的事物的形象
  - 类是对象的数据类型，类是具备雷同属性和行为的一组对象的汇合
  - 简略了解：类就是对事实事物的一种形容
- 类的组成
  - 属性：指事物的特色，例如：手机事物（品牌，价格，尺寸）
  - 行为：指事物能执行的操作，例如：手机事物（打电话，发短信）
类和对象的关系
- 类：类是对现实生活中一类具备独特属性和行为的事物的形象
- 对象：是可能看失去摸的着的实在存在的实体
- 简略了解：类是对事物的一种形容，对象则为具体存在的事物

类的组成是由属性和行为两局部组成

属性：在类中通过成员变量来体现（类中办法外的变量）
行为：在类中通过成员办法来体现（和后面的办法相比去掉 static 关键字即可）

类的定义步骤：

①定义类

②编写类的成员变量

③编写类的成员办法

public class 类名 {
    // 成员变量
    变量 1 的数据类型 变量 1；变量 2 的数据类型 变量 2;
    …
    // 成员办法
    办法 1;
    办法 2;    
}

示例代码：

/*
    手机类：类名：手机(Phone)

        成员变量：品牌(brand)
        价格(price)

        成员办法：打电话(call)
        发短信(sendMessage)
 */
public class Phone {
    // 成员变量
    String brand;
    int price;

    // 成员办法
    public void call() {System.out.println("打电话");
    }

    public void sendMessage() {System.out.println("发短信");
    }
}

创建对象的格局：
- 类名对象名 = new 类名();
调用成员的格局：
- 对象名. 成员变量
- 对象名. 成员办法();
示例代码

/*
    创建对象
        格局：类名 对象名 = new 类名();
        范例：Phone p = new Phone();

    应用对象
        1：应用成员变量
            格局：对象名. 变量名
            范例：p.brand
        2：应用成员办法
            格局：对象名. 办法名()
            范例：p.call()
 */
public class PhoneDemo {public static void main(String[] args) {
        // 创建对象
        Phone p = new Phone();

        // 应用成员变量
        System.out.println(p.brand);
        System.out.println(p.price);

        p.brand = "小米";
        p.price = 2999;

        System.out.println(p.brand);
        System.out.println(p.price);

        // 应用成员办法
        p.call();
        p.sendMessage();}
}

需要：首先定义一个学生类，而后定义一个学生测试类，在学生测试类中通过对象实现成员变量和成员办法的应用
剖析：
- 成员变量：姓名，年龄…
- 成员办法：学习，做作业…
示例代码：

public class Student {
    // 成员变量
    String name;
    int age;

    // 成员办法
    public void study() {System.out.println("好好学习，天天向上");
    }

    public void doHomework() {System.out.println("键盘敲烂，月薪过万");
    }
}
/*
    学生测试类
 */
public class StudentDemo {public static void main(String[] args) {
        // 创建对象
        Student s = new Student();

        // 应用对象
        System.out.println(s.name + "," + s.age);

        s.name = "林青霞";
        s.age = 30;

        System.out.println(s.name + "," + s.age);

        s.study();
        s.doHomework();}
}

成员变量应用过程

成员办法调用过程

成员变量应用过程

成员办法调用过程

总结：

多个对象在堆内存中，都有不同的内存划分，成员变量存储在各自的内存区域中，成员办法多个对象共用的一份

类中地位不同：成员变量（类中办法外）局部变量（办法外部或办法申明上）
内存中地位不同：成员变量（堆内存）局部变量（栈内存）
生命周期不同：成员变量（随着对象的存在而存在，随着对象的隐没而隐没）局部变量（随着办法的调用而存在，醉着办法的调用结束而隐没）
初始化值不同：成员变量（有默认初始化值）局部变量（没有默认初始化值，必须先定义，赋值能力应用）

封装概述
是面向对象三大特色之一（封装，继承，多态）

对象代表什么，就得封装对应的数据，并提供数据对应的行为
封装代码实现
将类的某些信息暗藏在类外部，不容许内部程序间接拜访，而是通过该类提供的办法来实现对暗藏信息的操作和拜访
成员变量 private，提供对应的 getXxx()/setXxx()办法

private 是一个修饰符，能够用来润饰成员（成员变量，成员办法）

被 private 润饰的成员，只能在本类进行拜访，针对 private 润饰的成员变量，如果须要被其余类应用，提供相应的操作
- 提供“get 变量名()”办法，用于获取成员变量的值，办法用 public 润饰
- 提供“set 变量名(参数)”办法，用于设置成员变量的值，办法用 public 润饰

示例代码：

/*
    学生类
 */
class Student {
    // 成员变量
    String name;
    private int age;

    // 提供 get/set 办法
    public void setAge(int a) {if(a<0 || a>120) {System.out.println("你给的年龄有误");
        } else {age = a;}
    }

    public int getAge() {return age;}

    // 成员办法
    public void show() {System.out.println(name + "," + age);
    }
}
/*
    学生测试类
 */
public class StudentDemo {public static void main(String[] args) {
        // 创建对象
        Student s = new Student();
        // 给成员变量赋值
        s.name = "林青霞";
        s.setAge(30);
        // 调用 show 办法
        s.show();}
}

需要：定义规范的学生类，要求 name 和 age 应用 private 润饰，并提供 set 和 get 办法以及便于显示数据的 show 办法，测试类中创建对象并应用，最终控制台输入林青霞，30

示例代码：

/*
    学生类
 */
class Student {
    // 成员变量
    private String name;
    private int age;

    //get/set 办法
    public void setName(String n) {name = n;}

    public String getName() {return name;}

    public void setAge(int a) {age = a;}

    public int getAge() {return age;}

    public void show() {System.out.println(name + "," + age);
    }
}
/*
    学生测试类
 */
public class StudentDemo {public static void main(String[] args) {
        // 创建对象
        Student s = new Student();

        // 应用 set 办法给成员变量赋值
        s.setName("林青霞");
        s.setAge(30);

        s.show();

        // 应用 get 办法获取成员变量的值
        System.out.println(s.getName() + "---" + s.getAge());
        System.out.println(s.getName() + "," + s.getAge());

    }
}

this 润饰的变量用于指代成员变量，其次要作用是（辨别局部变量和成员变量的重名问题）
- 办法的形参如果与成员变量同名，不带 this 润饰的变量指的是形参，而不是成员变量
- 办法的形参没有与成员变量同名，不带 this 润饰的变量指的是成员变量

public class Student {
    private String name;
    private int age;

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

    public String getName() {return name;}

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

    public int getAge() {return age;}

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

构造方法是一种非凡的办法

作用：创建对象 Student stu = new Student();
格局：

public class 类名{

修饰符类名(参数) {

}

}
性能：次要是实现对象数据的初始化
示例代码：

class Student {
    private String name;
    private int age;

    // 构造方法
    public Student() {System.out.println("无参构造方法");
    }

    public void show() {System.out.println(name + "," + age);
    }
}
/*
    测试类
 */
public class StudentDemo {public static void main(String[] args) {
        // 创建对象
        Student s = new Student();
        s.show();}
}

构造方法的创立

如果没有定义构造方法，零碎将给出一个默认的无参数构造方法
如果定义了构造方法，零碎将不再提供默认的构造方法

构造方法的重载

如果自定义了带参构造方法，还要应用无参数构造方法，就必须再写一个无参数构造方法

举荐的应用形式

无论是否应用，都手工书写无参数构造方法

重要性能！

能够应用带参结构，为成员变量进行初始化

示例代码

/*
    学生类
 */
class Student {
    private String name;
    private int age;

    public Student() {}

    public Student(String name) {this.name = name;}

    public Student(int age) {this.age = age;}

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

    public void show() {System.out.println(name + "," + age);
    }
}
/*
    测试类
 */
public class StudentDemo {public static void main(String[] args) {
        // 创建对象
        Student s1 = new Student();
        s1.show();

        //public Student(String name)
        Student s2 = new Student("林青霞");
        s2.show();

        //public Student(int age)
        Student s3 = new Student(30);
        s3.show();

        //public Student(String name,int age)
        Student s4 = new Student("林青霞",30);
        s4.show();}
}

① 类名须要见名知意

② 成员变量应用 private 润饰

③ 提供至多两个构造方法

无参构造方法
带全副参数的构造方法

④ get 和 set 办法

提供每一个成员变量对应的 setXxx()/getXxx()

⑤ 如果还有其余行为，也须要写上

需要：

定义规范学生类，要求别离应用空参和有参构造方法创建对象，空参创立的对象通过 setXxx 赋值，有参创立的对象间接赋值，并通过 show 办法展现数据。

示例代码：

class Student {
    // 成员变量
    private String name;
    private int age;

    // 构造方法
    public Student() {}

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

    // 成员办法
    public void setName(String name) {this.name = name;}

    public String getName() {return name;}

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

    public int getAge() {return age;}

    public void show() {System.out.println(name + "," + age);
    }
}
/*
    创建对象并为其成员变量赋值的两种形式
        1: 无参构造方法创建对象后应用 setXxx()赋值
        2: 应用带参构造方法间接创立带有属性值的对象
*/
public class StudentDemo {public static void main(String[] args) {// 无参构造方法创建对象后应用 setXxx()赋值
        Student s1 = new Student();
        s1.setName("林青霞");
        s1.setAge(30);
        s1.show();

        // 应用带参构造方法间接创立带有属性值的对象
        Student s2 = new Student("林青霞",30);
        s2.show();}
}

public class User {
    //1. 私有化全副的成员变量
    //2. 空参结构
    //3. 带全副参数的结构
    //4. 针对于每一个私有化的成员变量都要提供其对应的 get 和 set 办法
    //5. 如果以后事物还有其余行为，那么也要写进去，比方学生的吃饭，睡觉等行为

    private String username;// 用户名
    private String password;// 明码
    private String email;// 邮箱
    private char gender;// 性别
    private int age;// 年龄

    // 空参构造方法
    public User() {}

    // 带全副参数的结构
    public User(String username, String password, String email, char gender, int age) {
        this.username = username;
        this.password = password;
        this.email = email;
        this.gender = gender;
        this.age = age;
    }

    //get 和 set

    public String getUsername() {return username;}

    public void setUsername(String username) {this.username = username;}

    public String getPassword() {return password;}

    public void setPassword(String password) {this.password = password;}

    public String getEmail() {return email;}

    public void setEmail(String email) {this.email = email;}

    public char getGender() {return gender;}

    public void setGender(char gender) {this.gender = gender;}

    public int getAge() {return age;}

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

    public void eat(){System.out.println(username + "在吃饭");
    }
}

public class Test {public static void main(String[] args) {
        // 写一个规范的 javabean 类
        // 咱们在课后只有能把这个规范的 javabean 能本人写进去，那么就示意明天的知识点就 ok 了


        // 利用空参结构创建对象
        User u1 = new User();
        // 如果利用空参创建对象，还想赋值只能用 set 办法赋值
        u1.setUsername("zhangsan");
        u1.setPassword("1234qwer");
        u1.setEmail("itheima@itcast.cn");
        u1.setGender('男');
        u1.setAge(23);
        // 获取属性的值并打印
        System.out.println(u1.getUsername() + "," + u1.getPassword()
                + "," + u1.getEmail() + "," + u1.getGender() + "," + u1.getAge());
        u1.eat();

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

        // 简略的方法
        // 利用带全副参数的结构来创建对象
        // 快捷键:ctrl + p
        User u2 = new User("lisi","12345678","lisi@itcast.cn",'女',24);
        System.out.println(u2.getUsername() + "," + u2.getPassword()
                + "," + u2.getEmail() + "," + u2.getGender() + "," + u2.getAge());
        u2.eat();}
}

正文完

java

发表至： java

2023-02-09

0

面试题寻找一个字符串中出现次数最多的字符以及出现的次数

hadoop配置与wordcount

关于java:OAuth2-检验token的-获取用户信息

关于java:Java实现多用户即时通信系统

关于大数据:有了-ETL-数据神器-dbt表数据秒变-NebulaGraph-中的图数据

关于java:类和对象

1. 类和对象

1.1 类和对象的了解

1.2 类的定义

1.3 对象的应用

1.4 学生对象 - 练习

2. 对象内存图

2.1 单个对象内存图

2.2 多个对象内存图

3. 成员变量和局部变量

3.1 成员变量和局部变量的区别

4. 封装

4.1 封装思维

4.2 private 关键字

4.3 private 的应用

4.4 this 关键字

5. 构造方法

5.1 构造方法概述

5.2 构造方法的注意事项

5.3 规范类制作

5.4 练习 1

5.4 练习 2

站内搜索