关于java:类和对象

1. 类和对象

1.1 类和对象的了解

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

• 类

  • 类的了解

    • 类是对现实生活中一类具备独特属性和行为的事物的形象
    • 类是对象的数据类型，类是具备雷同属性和行为的一组对象的汇合
    • 简略了解：类就是对事实事物的一种形容

  • 类的组成

    • 属性：指事物的特色，例如：手机事物（品牌，价格，尺寸）
    • 行为：指事物能执行的操作，例如：手机事物（打电话，发短信）

• 类和对象的关系

  • 类：类是对现实生活中一类具备独特属性和行为的事物的形象
  • 对象：是可能看失去摸的着的实在存在的实体
  • 简略了解：类是对事物的一种形容，对象则为具体存在的事物

1.2 类的定义

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

• 属性：在类中通过成员变量来体现（类中办法外的变量）
• 行为：在类中通过成员办法来体现（和后面的办法相比去掉 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("发短信");
    }
}

1.3 对象的应用

• 创建对象的格局：

  • 类名 对象名 = 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();}
}

1.4 学生对象 - 练习

• 需要：首先定义一个学生类，而后定义一个学生测试类，在学生测试类中通过对象实现成员变量和成员办法的应用

• 剖析：

  • 成员变量：姓名，年龄…
  • 成员办法：学习，做作业…
• 示例代码：

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();}
}

2. 对象内存图

2.1 单个对象内存图

• 成员变量应用过程

• 成员办法调用过程

2.2 多个对象内存图

• 成员变量应用过程

• 成员办法调用过程

• 总结：

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

3. 成员变量和局部变量

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

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

4. 封装

4.1 封装思维

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

   对象代表什么，就得封装对应的数据，并提供数据对应的行为

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

4.2 private 关键字

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();}
  }

4.3 private 的应用

• 需要：定义规范的学生类，要求 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());
  
      }
  }

4.4 this 关键字

• 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);
    }
}

5. 构造方法

5.1 构造方法概述

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

• 作用：创建对象 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();}
}

5.2 构造方法的注意事项

• 构造方法的创立

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

• 构造方法的重载

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

• 举荐的应用形式

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

• 重要性能！

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

• 示例代码

/*
    学生类
 */
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();}
}

5.3 规范类制作

① 类名须要见名知意

② 成员变量应用 private 润饰

③ 提供至多两个构造方法

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

④ get 和 set 办法

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

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

5.4 练习 1

需要：

​ 定义规范学生类，要求别离应用空参和有参构造方法创建对象，空参创立的对象通过 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();}
}

5.4 练习 2

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();}
}