day07.面向对象

课前回顾:
  1.方法的重载:
    a.概述:方法名相同,参数列表不同
    b.什么叫参数列表不同:
      个数不同
      参数类型不同
      参数类型的顺序不同
    c.和什么无关:
      和返回值无关;和参数名无关
  2.面向对象:
    a.概述:是java的核心编程思想,讲究的是调用别人写好的功能,直接拿过来用
    b.为啥使用:
      为了减少代码
    c.啥时候使用:
      在一个类中想调用其他类中的成员
    d.怎么用:
      new对象,调用方法
      类名直接调用 -> 调用的是别的类的带static的成员
  3.类和对象:
    a.实体类的定义:
      属性:成员变量
      行为:成员方法
    b.对象:
      导包:import 包名.类名
          两个类不在同一个包下,需要导包
          两个类在同一个包下,不需要导包
      创建对象:
          类名 对象名 = new 类名()
      调用:
          对象名.

  4.匿名对象
    a.概述:没有等号左边的部分,只有new的部分
    b.注意:
      设计到赋值,不要使用
  5.成员变量和局部变量的区别:
    a.定义位置不同:
      成员:类中方法外
      局部:方法内
    b.作用范围不同
      成员:整个类
      局部:方法内部
    c.初始化值不同
      成员:有默认值
      局部:没有默认值,需要先初始化再使用
    d.内存位置不同
      成员:堆中
      局部:栈中
    e.生命周期不同
      成员:随着对象的创建而创建,随着对象的消失而消失
      局部:随着方法的调用而创建,随着方法的执行完毕而消失

 5.注意:
   如果属性为自定义类型,一定要通过new对象去赋值

今日重点:
  all

第一章.封装

面向对象三大特征:
  [封装]

  继承

  多态

1.封装的介绍以及使用

1.封装从生活角度来说:将一个物品封起来,外界不能直接使用
2.封装从java角度来说:将细节隐藏起来(不让外界直接使用),对外提供一套公共的接口(供外界通过这个公共的接口间接使用隐藏起来的细节)

3.举例说明:
  a.洗衣机洗衣服:
    我们使用洗衣机洗衣服,属于面向对象思想编程
    我们使用的时候直接点击按钮,洗衣机就洗衣服了(按钮下的零部件就是我们隐藏起来的细节,按钮就是对外提供的公共接口,我们通过按钮间接操作洗衣机的零部件)

1.封装怎么用:
  a.将代码放到一个方法中,方法体就是我们隐藏起来的细节,方法名就是对外提供的公共接口 -> 我们直接通过调用方法名,方法内部的细节就执行了,至于这个方法怎么实现的,我们无需关注,我们只关注调用方法

  b.将成员私有化 -> private
    private -> 代表的是私有的,被私有化的成员只能在自己当前类中使用

    private可以修饰成员变量,也可以修饰方法


2.封装总结一句话:将细节隐藏起来(不让外界直接使用),对外提供一套公共的接口(供外界通过这个公共的接口间接使用隐藏起来的细节)

1.用private修饰成员之后(相当于隐藏细节)
2.提供getxxx/setxxx方法(相当于对外提供的公共接口)
  a.setxxx:为属性赋值
  b.getxxx:获取属性值

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

    /**
     * 针对私有化的name提供getxxx/setxxx方法
     */
    public void setName(String xingMing) {
        name = xingMing;
    }

    public String getName() {
        return name;
    }

    public void setAge(int nianLing) {
        if (nianLing <= 0) {
            System.out.println("年龄不合法");
        } else {
            age = nianLing;
        }
    }

    public int getAge() {
        return age;
    }
}

public class Test01 {
    public static void main(String[] args) {
        Person person = new Person();
        //person.name = "萌姐";
        //person.age = 38;
        //System.out.println(person.name);
        //System.out.println(person.age);
        person.setName("萌姐");
        person.setAge(-38);

        String name = person.getName();
        int age = person.getAge();
        System.out.println(name+"..."+age);

    }
}

2.this 的介绍

1.注意:当成员变量和局部变量重名的时候,遵循"就近原则",先走局部变量
2.this关键字:
  a.概述:代表的是当前对象
  b.用法:this.成员的
3.this代表的是当前对象,具体代表哪个当前对象呢?
  哪个对象调用的this所在的方法,this就代表哪个对象

public class Person {
     String name;
     public void speak(String name){
         System.out.println(this+"...............");
         System.out.println(this.name+"您好,我是"+name);
     }
}

public class Test01 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person+"...");
        person.name = "沉香";
        person.speak("刘彦昌");

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

        Person person2 = new Person();
        System.out.println(person2+"......");
        person2.name = "王思聪";
        person2.speak("王健林");
    }
}

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

    //为name属性提供get/set方法

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

    public String getName() {
        return name;
    }

    //为age属性提供get/set方法

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

    public int getAge() {
        return age;
    }
}

public class Test01 {
    public static void main(String[] args) {
        Person person1 = new Person();
        person1.setName("萌姐");
        person1.setAge(48);
        System.out.println(person1.getName()+"..."+person1.getAge());

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

        Person person2 = new Person();
        person2.setName("涛哥");
        person2.setAge(18);
        System.out.println(person2.getName()+"..."+person2.getAge());
    }
}

问题:get/set 方法只能对私有属性赋值取值吗?

​ get/set 方法可以对私有和非私有属性赋值,但是如果属性不是 private 的,我们可以直接调用,用不着 get/set 方法,只有属性私有化了,get/set 方法才有真正的作用

3.构造方法

1.构造方法作用:
  主要是new对象的
2.特点:
  a.方法名和类名一致
  b.没有返回值,连void都没有

3.1 空参构造

1.格式:
  public 类名(){

  }

2.作用:
  new对象使用

3.注意:
  a.我们一new,就相当于调用了构造方法
  b.jvm会为每个类都提供一个空参构造,不写也有

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

    //空参构造
    public Person(){
        System.out.println("我是空参构造");
    }

    //为name属性提供get/set方法

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

    public String getName() {
        return name;
    }

    //为age属性提供get/set方法

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

    public int getAge() {
        return age;
    }
}

public class Test01 {
    public static void main(String[] args) {
        Person person1 = new Person();
    }
}

构造方法可以是其他的权限修饰符,比如 private 修饰,如果被 private 修饰了构造方法,我们就不能利用构造方法 new 对象了

3.2 有参构造

1.格式:
  public 类名(形参){
      为属性赋值
  }

2.作用:
  a.创建对象
  b.为属性赋值

3.注意:
  如果写上了有参构造,jvm将不再提供无参构造了,所以建议都写上

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

    //空参构造
    public Person(){
        System.out.println("我是空参构造");
    }

    //有参构造
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    //为name属性提供get/set方法

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

    public String getName() {
        return name;
    }

    //为age属性提供get/set方法

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

    public int getAge() {
        return age;
    }
}

public class Test01 {
    public static void main(String[] args) {
        Person person1 = new Person();

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

        Person person2 = new Person("张无忌",25);
        System.out.println(person2.getName());
        System.out.println(person2.getAge());
    }
}

问题:既然有参构造既能 new 对象,还能为属性赋值,那么将来我们就不写 set 方法了,可以吗?

不行

如果我们使用有参构造为属性赋值,我们的代码是: Person p = new Person("张三",18),我们后续需要将p对象的name改成"李四",我们不可能重新new,重新赋值
此时我们可以单独调用setName方法,单独为name赋值

4.标准 JavaBean

JavaBean 是 Java语言编写类的一种标准规范。符合JavaBean` 的类，要求：

（1）类必须是具体的(非抽象 abstract)和公共的，public class 类名

（2）并且具有无参数的构造方法

（3）成员变量私有化，并提供用来操作成员变量的set 和get 方法。

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

    //空参构造
    public Person(){
        System.out.println("我是空参构造");
    }

    //有参构造
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    //为name属性提供get/set方法

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

    public String getName() {
        return name;
    }

    //为age属性提供get/set方法

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

    public int getAge() {
        return age;
    }
}

编写符合JavaBean 规范的类，以学生类为例，标准代码如下：

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

    public Student() {
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

通用快捷键:

alt+insert

fn+alt+insert

1.无参构造

2.有参构造:

3.get/set 方法

public class Test01 {
    public static void main(String[] args) {
        Student student = new Student();
        student.setId(1);
        student.setName("张三");
        System.out.println(student.getId()+"..."+student.getName());

        System.out.println("=======================");
        Student student1 = new Student(2, "李四");
        System.out.println(student1.getId()+"..."+student1.getName());
    }
}

5.JavaBean 怎么来的(扩展说明)

1.开发要分包分层:
  com.atguigu.controller(表现层)  存放接收请求回响应的类-> 和页面打交道
  com.atguigu.service(业务层) 存放写业务逻辑的类
  com.atguigu.dao/mapper(持久层) 存放和数据库打交道的类
  com.atguigu.pojo/entity 存放javabean类的
  com.atguigu.utils  存放工具类

5.1.javabean 在开发中的实际运用_添加功能

将页面上发送过来的请求封装到 javabean 中,然后一层一层传递给 dao 层,然后和 sql 语句使用

5.2.javabean 在实际开发中运用_查询功能

将从数据库中查询出来的结果封装成多个 javabean 对象,然后将多个 javabean 对象放到集合中,一起返回给页面,进行展示

封装小结:

1.知道什么是封装吗? 将细节隐藏起来,对外提供公共的接口

2.你知道 private 的作用嘛? 私有化成员,外界不能直接使用

3.知道 set 方法的作用嘛? 为属性赋值

4.知道 get 方法的作用嘛? 获取属性值

5.知道 this 的作用嘛? 区分重名的成员变量和局部变量

6.知道无参构造作用嘛? new 对象的

7.知道有参构造作用嘛? new 对象并为属性赋值

8.知道如何使用快捷键快速生成一个标准 javabean 类嘛? alt+insert

第二章.static 关键字

1.static 的介绍以及基本使用

1.概述: static静态关键字
2.使用:
   a.修饰成员变量:  static 数据类型 变量名
   b.修饰方法:
      修饰符 static 返回值类型 方法名(形参){
                 方法体
                  return 结果
      }

3.static的特点:
   a.静态成员属于类成员,静态成员会随着类的加载而加载
   b.静态成员会优先于对象存在(非静态成员属于对象的成员)
   c.凡是根据static所在的类创建出来的对象,都可以共享这个静态成员

4.调用:
   类名直接点

public class Student {
    int id;
    String name;
    static String classRoom;
}

public class Test01 {
    public static void main(String[] args) {
        //类名直接调用
        Student.classRoom = "教研室9";

        Student s1 = new Student();
        s1.id = 1;
        s1.name = "张三";
        s1.classRoom = "教研室90";
        System.out.println(s1.id);
        System.out.println(s1.name);
        System.out.println(s1.classRoom);

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

        Student s2 = new Student();
        s2.id = 2;
        s2.name = "李四";
        s2.classRoom = "教研室900";
        System.out.println(s2.id);
        System.out.println(s2.name);
        System.out.println(s2.classRoom);
        //System.out.println(s1.classRoom);
    }
}

2.static 修饰成员的访问特点

1.在静态方法中能直接访问非静态成员嘛?不能
  new对象访问

2.在静态方法中能直接访问静态成员嘛?能
  a.在同一个类中 -> 直接调用
  b.不在同一个类中 -> 类名调用

3.在非静态方法中能直接访问静态成员嘛?能
  a.在同一个类中 -> 直接调用
  b.不在同一个类中 -> 类名调用

4.在非静态方法中能直接访问非静态成员嘛?能
  a.在同一个类中 -> 直接调用
  b.不在同一个类中 -> new对象调用

总结:

​ 1.调用静态的:不管在不在同一个类中,能直接调用就直接调用,不能直接调用类名调用

​ 2.调用非静态的:不管在不在同一个类中,能直接调用就直接调用,不能直接调用就 new 对象调用

问题1:既然静态的那么好使,直接类名点即可,那么将来写代码能不能将所有的成员都定义成静态的?
    不能
原因:静态的属于类成员,会随着类的加载而加载,如果将所有的成员都变成静态的,类一加载,这个类中所有的静态成员都会被加载,包括没有用到的,所以会造成占用内存空间,浪费内存的弊端


问题2:啥时候定义静态成员呢?
     静态成员一般情况都是在抽取工具类的时候定义

问题3:啥时候抽取工具类
      如果每个类中反复实现同一个功能,此时我们没必要在每一个类中都重复写相同的代码,此时我们就可以将这段代码抽取到一个工具类中

public class ArraysUtils {
    /**
     * 工具类中的构造要求私有化
     * 不让外界通过构造new对象
     */
    private ArraysUtils(){}

    public static void printArray(int[] arr){
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                System.out.print(arr[i] + "]");
            } else {
                System.out.print(arr[i] + ",");
            }
        }
    }
}

public class Test01 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        ArraysUtils.printArray(arr);
    }
}

public class Test02 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        ArraysUtils.printArray(arr);
    }
}

public class Test03 {
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55};
        ArraysUtils.printArray(arr);
    }
}