自学Java (day6)，面向对象

Java自学（day6）

一：设计对象，注意事项

1.设计对象：

类设计图：是对象共同特征的描述；

对象：是真实存在的具体实例。

结论：在Java中，必须先设计类，才能创建对象并使用

案例：

1.创建一个student类

public class Student {
    //成员变量
    String name ;
    double hours ;

    //方法
    public void study(){
        System.out.println(name+"开始学习了");
    }
    public void time(){
        System.out.println("学习了"+hours+"个小时");
    }
}

2.在test中调用Student

public class test {
    public static void main(String[] args) {
        //调用创建的类
        Student a = new Student();
        a.name = "张三";
        a.hours = 4;
        System.out.println(a.name);
        System.out.println(a.hours);
        //调用类中的方法
        a.study();
        a.time();
        System.out.println("------------------");
        //调用创建的类
        Student a2 = new Student();
        a2.name = "李四";
        a2.hours= 5;
        System.out.println(a2.name);
        System.out.println(a2.hours);
        //调用类中的方法
        a2.study();
        a2.time();
    }
}

2.定义类的补充注意事项:

• 类名首字母建议大写，且有意义，满足“驼峰模式”。

• 一个Java文件中可以定义多个class类，但只能一个类是public修饰，而且public修饰的类名必须成为代码文件名。

• 实际开发中建议还是一个文件定义一个class类。

• 成员变量的完整定义格式是：修饰符 数据类型 变量名称 = 初始化值； 一般无需指定初始化值，存在默认值。

  数据类型	明细	默认值
  	byte、short、char、int、long	0
  基本类型	float、double	0.0
  	boolean	false
  引用类型	类、接口、数组、String	null

二：面向对象内存运行机制

1. 对象到底是放在哪个位置的？

• 堆内存中

2. Car c = new Car(); c变量名中存储的是什么？

• 存储的是对象在堆内存中的地址。

3. 成员变量（name、price）的数据放在哪里，存在于哪个位置？

• 对象中，存在于堆内存中。

两个变量指向同一个对象内存图 ：

1.创建一个Student1的类

public class Student1 {
    String name;
    char sex;
    String hobby;

    public void Study(){
        System.out.println("姓名："+name+",性别："+sex+",爱好："+hobby+"的学生：开始学习了！");
    }
}

2.调用

public class test1 {
    public static void main(String[] args) {
        //调用Student1这个类
        Student1 a = new Student1();

        a.name = "李华";
        a.sex = '男';
        a.hobby = "吃饭，睡觉，学习";
        //调用方法
        a.Study();
        //将a的值赋给b，传递的是地址
        Student1 b = a;
        b.hobby = "唱，跳，rap和打篮球";

        System.out.println(a.name);
        System.out.println(a.sex);
        System.out.println(a.hobby);

        a.Study();
        b.Study();
    }
}

输出结果：姓名：李华,性别：男,爱好：吃饭，睡觉，学习的学生：开始学习了！
李华
男
唱，跳，rap和打篮球
姓名：李华,性别：男,爱好：唱，跳，rap和打篮球的学生：开始学习了！
姓名：李华,性别：男,爱好：唱，跳，rap和打篮球的学生：开始学习了！

垃圾回收：

• 注意：当堆内存中的对象，没有被任何变量引用（指向）时，就会被判定为内存中的**“垃圾”。**

三：构造器

1.构造器的作用：

• 定义在类中的，可以用于初始化一个类的对象，并返回对象的地址。

2.构造器的格式：

• 修饰符 类名(形参列表){…}

• public class Car {…

  ​ // 无参数构造器

  ​ public Car(){…}

  ​ // 有参数构造器

  ​ public Car(String n, double p){…}

  }

3.调用构造器得到对象的格式：

• 类 变量名称 = new 构造器；

• Car c = new Car();

• Car c1 = new Car(“奔驰”, 39.8);

4.构造器的分类和作用：

• 无参数构造器（默认存在的）：初始化对象时，成员变量的数据均采用默认值。

• 有参数构造器：在初始化对象的时候，同时可以接收参数为对象进行赋值。

  案例：

  1.创建Car类

  public class Car {
      String name;
      double price;
  
      public Car (){
          System.out.println("==调用了无参数构造器==");
      }
      public Car (String n,double p){
          System.out.println("==调用了有参数构造器==");
          name = n;
          price = p;
      }
  }
  

  2.调用创建类中的构造器

  public class test2 {
      public static void main(String[] args) {
          //调用无参数构造器
          Car a = new Car();
          a.name = "宝马";
          a.price = 30;
          System.out.println(a.name);
          System.out.println(a.price);
  
          //调用有参数构造器
          Car b = new Car("奔驰",40);
          System.out.println(b.name);
          System.out.println(b.price);
      }
  }
  

5.构造器的注意事项

• 任何类定义出来，默认就自带了无参数构造器，写不写都有。
• 一旦定义了有参数构造器，那么无参数构造器就没有了，如果还想用无参数构造器，此时就需要自己手写一个无参数构造器了。

四：this 关键字

1.this关键字是什么？

• 可以出现在构造器、方法中。

• 代表当前对象的地址。

2.this关键字的作用

• 可以用于指定访问当前对象的成员变量、成员方法。

public class Car {
    String name;
    double price;

    public Car (){
        System.out.println("==调用了无参数构造器==");
    }
    public Car (String name,double price){
        System.out.println("==调用了有参数构造器==");
        this.name = name;
        this.price = price;
    }
}

五.封装

1.面向对象的三大特征：

封装，继承，多态。

2.封装：

告诉我们，如何正确设计对象的属性和方法。

3.封装的原则：

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

4.封装原则：

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

5.如何进行封装更好？

• 一般建议对成员变量使用private(私有、隐藏)关键字修饰进（private修饰的成员只能在当前类中访问）。

• 为每个成员变量提供配套public修饰的的getter、setter方法暴露其取值和赋值。

6.案例：

public class Student {
    //1.成员变量使用private修饰，就只能在这个类中使用了
    private int age;

    //2.提供成套的setter和getter的方法，暴露其赋值和取值
    public void setAge(int age){
        if (age > 0 && age <=100){
            this.age = age;
        }else {
            System.out.println("你输入的年龄有误，请重新输入！");
        }
    }
    public int getAge(){
        return age;
    }
}

public class Demo {
    //学习如何进行更好的封装
    public static void main(String[] args) {
        Student s = new Student();
        s.setAge(-24);
        System.out.println(s.getAge());

    }
}

六.JavaBean

1.JavaBean:

也可以称为实体类，其对象可以用于在程序中封装数据。

2.标准JavaBean须满足如下书写要求：

成员变量使用 private 修饰。

提供成员变量对应的 **setXxx() /getXxx()**方法。

必须提供一个无参构造器；有参数构造器是可写可不写的。

3.案例：

public class User {
    //javabean的书写格式，
    //1.使用private修饰成员变量
    private String name;
    private double height;
    private double salary;

    //3.要求提供无参数构造器，有参数为可选

    //无参数构造器
    public User() {
    }
    //有参数构造器

    public User(String name, double height, double salary) {
        this.name = name;
        this.height = height;
        this.salary = salary;
    }


    //2.必须为成员变量提供成套的setter和getter方法，可直接快捷生成

    public String getName() {return name;}

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

    public double getHeight(){return height;}

    public void setHeight(double height){this.height = height;}

    public double getSalary(){return salary;}

    public void setSalary(double salary){this.salary = salary;}
}

public class Test {
    public static void main(String[] args) {
        //调用User对象
        //1.无参数构造器创建对象封装一个用户信息
        User u = new User();
        u.setName("吕布");
        u.setHeight(185);
        u.setSalary(10000);
        System.out.println("我的名字是："+u.getName());
        System.out.println("我的身高是："+u.getHeight());
        System.out.println("我的薪水是："+u.getSalary()+"银元");
        System.out.println("--------------------------------------");
        //2.有参数构造器创建对象封装一个用户对象
        User u2 = new User("九江彭于晏",180,10000);
        System.out.println("我的名字是："+u2.getName());
        System.out.println("我的身高是："+u2.getHeight()+"cm");
        System.out.println("我的薪水是："+u2.getSalary()+"米");
    }
}

七.面向对象综合案例

public class Movie {
    //1.使用private定义成员变量
    private String name;
    private double score;
    private String actor;

    //2.定义有参数构造器和无参数构造器

    public Movie() {
    }
    public Movie(String name, double score, String actor) {
        this.name = name;
        this.score = score;
        this.actor = actor;
    }
    //3.必须为成员变量提供成套的setter和getter方法

    public String getName() {
        return name;}
    public void setName(String name) {
        this.name = name;}
    public double getScore() {
        return score;}
    public void setScore(double score) {
        this.score = score;}
    public String getActor() {
        return actor;}
    public void setActor(String actor) {
        this.actor = actor;}
}

public class Test {
    //目标：完成电影信息的展示案例，理解面向对象编程的代码
    //"《长津湖》",9.7,"吴京"
    //"《我和我的父亲》",9.6,"吴京"
    //"《扑水少年》",9.5,"王川"
    public static void main(String[] args) {
        //1.设计电影类
        //2.创建3个电影对象，封装电影的信息
        //3.定义一个电影类型的数组，将信息存储起来
        Movie[] movies= new Movie [3];
        movies[0] = new Movie("《长津湖》",9.7,"吴京");
        movies[1] = new Movie("《我和我的父亲》",9.6,"吴京");
        movies[2] = new Movie("《扑水少年》",9.5,"王川");
        //4.遍历数组，将其中的数据展示出来
        for (int i = 0; i < movies.length; i++) {
            Movie m = movies[i];
            System.out.println("电影名："+m.getName());
            System.out.println("分数："+m.getScore());
            System.out.println("主演："+m.getActor());
            System.out.println("-----------------------------");
        }
    }
}

输出结果：

电影名：《长津湖》
分数：9.7

主演：吴京

---

电影名：《我和我的父亲》
分数：9.6

主演：吴京

---

电影名：《扑水少年》
分数：9.5

主演：王川

---

数组中存储的元素并不是对象本身，而是对象的地址。