20200701

面向对象

面向过程：当需要实现一个功能的时候，每一个具体的步骤都要亲历亲为，详细处理每一个细节

面向对象：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人来帮我做事

public class Demo01PrintArray {
    public static void main(String[] args) {
        int[] array = {10, 20, 30, 40, 50};

        //要求打印格式为：[10， 20， 30， 40， 50]
        //使用面向过程，每一个步骤细节都要亲历亲为
        System.out.print("[");
        for (int i = 0; i < array.length; i++) {
            if(i == array.length - 1){
                System.out.println(array[i] + "]");
            }
            else{
                System.out.print(array[i] + ", ");
            }
        }
        System.out.println("============");

        //使用面向对象，找一个JDK给我们提供好的Arrays类
        //其中有一个toString方法，直接就能把数组变成想要的格式的字符串
        System.out.println(Arrays.toString(array));
    }
}

类与对象的关系

类是对一类事物的描述，是抽象的

对象是一类事物的实例，是具体的

类是对象的模板，对象的类是实体

定义一个类，用来模拟“学生”事物，其中有两个组成部分：

属性（是什么）：

         姓名

         年龄

行为（能做什么）：

         吃饭

         睡觉

         学习

对应到Java的类当中：

成员变量（属性）：

       String name ; //姓名

       int age ; // 年龄

成员方法（行为）：

        public void eat( ){ }  //吃饭

        public void sleep( ){ }  //睡觉

        public void study( ) { }  //学习 

public class student {

    //成员变量
    String name;
    int age;

    //成员方法
    public void eat(){
        System.out.println("吃饭饭！");
    }
    public void sleep(){
        System.out.println("睡觉觉！");
    }
    public void study(){
        System.out.println("学习！");
    }
}

注意事项：

成员变量是直接定义在类当中的，在方法外边

成员方法不要写static关键字

 

通常情况下，一个类并不能直接使用，需要根据类创建一个对象才能使用

1.导包：也就是指出需要使用的类在什么位置

import 包名称 . 类名称；

import cn.itcast.day0701.demo01.Student；

对于和当前类属于一个包的情况，可以省略导包语句不写

2.创建格式：

类名称 对象名 = new 类名称（）；

Student stu = new Student()；

3.使用分为两种情况

使用成员变量：对象名.成员变量名

使用成员方法：对象名.成员方法名（参数）；

public class Demo02Student {
    public static void main(String[] args) {
        //1.导包
        //我需要使用的Student类，和我自己Demo02Student位于同一个包下，所以省略导包语句不写
        //2.创建：类名称 对象名 = new 类名称（）；
        //根据Student类，创建了一个名为stu的对象
        student stu = new student();

        //3.使用其中的成员变量：对象名.成员变量名
        System.out.println(stu.name);//null
        System.out.println(stu.age);//0
        System.out.println("===============");

        //改变对象当中的成员变量数值内容
        //将右侧的字符串赋值交给stu对象当中的name成员变量
        stu.name = "宋智孝";
        stu.age = 18;
        System.out.println(stu.name);//宋智孝
        System.out.println(stu.age);//18

        //4.使用对象的成员方法：对象名.成员方法名（）
        stu.eat();//吃饭饭！
        stu.sleep();//睡觉觉！
        stu.study();//学习！
    }
}

注意事项：如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样

定义一个类，用来模拟“手机”事物

属性：品牌、价格、颜色

行为：打电话、发短信

对应到类当中：

成员变量（属性):

      String brand ; //品牌

      double price ; //价格

      String color ; //颜色

成员方法（行为）：

      public void call (String who ) { } //打电话

      public void sendMessage ( ) { } //群发短信

public class phone {
    //成员变量
    String brand;//品牌
    double price;//价格
    String color;//颜色

    //成员方法
    public void call(String who){
        System.out.println("给" + who + "打电话");
    }
    public void sendMessage(){
        System.out.println("群发短信");
    }
}

public class Demo01phoneOne {
    public static void main(String[] args) {
        //根据phone类创建一个名为one的对象
        //格式：类名称 对象名 = new 类名称（）;
        phone one = new phone();
        System.out.println(one.brand);//null
        System.out.println(one.price);//0.0
        System.out.println(one.color);//null
        System.out.println("===========");

        one.brand = "苹果";
        one.price = 8888.0;
        one.color = "黑色";
        System.out.println(one.brand);//苹果
        System.out.println(one.price);//8888.0
        System.out.println(one.color);//黑色
        System.out.println("===========");

        one.call("谢可寅");//给谢可寅打电话
        one.sendMessage();//群发短信
    }
}

内存图

使用对象类型作为方法的参数

public class Demo02phoneParam {
    public static void main(String[] args) {
        phone one = new phone();
        one.brand = "苹果";
        one.price = 8888.0;
        one.color = "土豪金";

        method(one);
    }
    public static void method(phone param){
        System.out.println(param.brand);
        System.out.println(param.price);
        System.out.println(param.color);
    }
}

局部变量和成员变量

• 定义的位置不一样

        局部变量：在方法的内部

        成员变量：在方法的外部，直接写在类当中

• 作用范围不一样

        局部变量：只有方法当中才可以使用，出了方法就不能再用

        成员变量：整个类全都可以通用

• 默认值不一样

       局部变量：没有默认值，如果想要使用必须手动进行赋值

       成员变量：如果没有赋值会有默认值，规则和数组一样

• 内存的位置不一样

      局部变量：位于栈内存

      成员变量：位于堆内存

• 生命周期不一样

       局部变量：随着方法进栈而诞生，随着方法出栈而消失

       成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失

面向对象三大特征：封装、继承、多态

封装性在Java当中的体现：

1.方法就是一种封装

2.关键字private也是一种封装

封装就是将一些细节信息隐藏起来，对于外界不可见

 

问题描述：定义Person的年龄时，无法阻止不合理的数值被设置进来

解决方案：用private关键字将需要保护的成员变量进行修饰

一旦使用了private进行修饰，那么本类当中仍然可以随意访问

但是超出了本类范围之外就不能再直接访问了

间接访问private成员变量，就是定义一对儿Getter/Setter方法

命名规则：必须叫setXxx或者getXxx  

对于Getter来说，不能有参数，返回值类型和成员变量对应

对于Setter来说，不能有返回值，参数类型和成员变量对应

public class Person {
    String name;
    private int age;

    public void show(){
        System.out.println("我叫：" + name + ",年龄：" + age);
    }
    //这个成员方法，专门用于向age设置数据
    public void setAge(int num){
        if(num < 100 && num >=0){
            age = num;
        }
        else{
            System.out.println("数据不合理！");
        }
    }
    //这个成员方法，专门用于获取age的数据
    public int getAge() {
        return age;
    }
}

public class Demo03Person {
    public static void main(String[] args) {
        Person person = new Person();
        person.show();

        person.name = "宋智孝";
        //间接访问
        person.setAge(20);
        person.show();
    }
}

对于基本类型当中的boolean值，Getter方法一定要写成isXxx的形式，而setXxx规则不变

当方法的局部变量和类的成员变量重名的时候，根据”就近原则“，优先使用局部变量

如果需要访问本类当中的成员变量，需要使用格式：this.成员变量名

public class Person {
    String name;//我自己的名字

    //参数name是对方的名字
    //成员变量name是自己的名字
    public void sayHello(String name){
        System.out.println(name + "，你好。我是" + this.name);
    }
}

public class Demo01Person {
    public static void main(String[] args) {
        Person person = new Person();
        //设置我自己的名字
        person.name = "王健林";
        person.sayHello("王思聪");//王思聪，你好。我是王健林
    }

通过谁调用的方法，谁就是this

构造方法

构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法

格式：

public 类名称（参数类型  参数名称）{

      方法体

}

注意事项：

• 构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样
• 构造方法不要写返回值类型，连void都不写
• 构造方法不能return一个具体的返回值
• 如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数、方法体什么事情都不做

        public Student( ) { }

• 一旦编写了至少一个构造方法，那么编译器将不再赠送
• 构造方法也是可以进行重载的

       重载：方法名称相同，参数列表不同

一个标准的类通常要拥有下面四个组成部分：

• 所有成员变量都要用Private关键字修饰
• 为每一个成员变量编写一个对Getter/Setter方法
• 编写一个无参数的构造方法
• 编写一个全参数的构造方法

这样标准的类也叫做Java Bean

public class Demo05Student {
    public static void main(String[] args) {
        Student stu1 = new Student();
        stu1.setName("谢可寅");
        stu1.setAge(20);
        System.out.println("姓名：" + stu1.getName() + ",年龄" + stu1.getAge());
        System.out.println("============");

        Student stu2 = new Student("宋智孝",21);
        System.out.println("姓名：" + stu2.getName() + ",年龄" + stu2.getAge());
        stu2.setAge(22);
        System.out.println("姓名：" + stu2.getName() + ",年龄" + stu2.getAge());
    }
}