day7 2021 2 10 类，对象B站版完整

面向对象与面向过程的区别

面向过程，所有程序都自己写，凡事亲力亲为

而面向对象，则是找人帮你做事，此时帮你做事的人就叫对象

package com.wang.Opp.Demo1;


//以打印数组为例子分辨面向对象和面向过程

import java.lang.reflect.Array;
import java.util.Arrays;

public class PrintArray {

    //面向过程打印数组
    //要求打印数组的格式  [10,20,30,40,50]
    //面向过程每一个步骤都要亲力亲为

    public static void main(String[] args) {
        int[] a = {10, 20, 30, 40, 50,60};
        System.out.print("[");
        for (int i = 0; i < a.length; i++) {
            if (i == a.length-1) {
                System.out.print(a[i]+"]");
            } else {
                System.out.print(a[i] + ", ");
            }
        }
        System.out.println("\n");

        //面向对象
        //找一个jdk中提供好的Arrays类
        //使用这个类中的toString方法
        //这个方法可以直接打印字符串
        System.out.println(Arrays.toString(a));
    }

}

面向对象的三大特征

封装性 继承性 多态性

类和对象

类

• 类：是一组相关的属性和行为的集合，可以看成是一类事物的模板
• 属性:就是该事物的状态信息
• 行为：就是该事物能做什么

类和对象的关系

• 类是一类事物的描述，是抽象的
• 对象是一类事物的实例，是具体的
• 类是对象的模板，对象是类的实体

类的定义

类的定义：

属性：是什么 也就是成员变量

行为：能做什么 也就是成员方法

在代码中的解释：

package com.wang.Opp.Dmeo2;

/*
属性（是什么）
   姓名
   年龄

行为（能做什么）
   吃饭
   睡觉
   学习

   对应到Java

   成员变量（属性）
      String name //姓名
      int age//年龄
   成员方法（行为）//不加static
      public void eat(){}//吃饭
      public void sleep(){}//学习
      public void study(){}//睡觉

 */

//注意事项：
//1.成员变量是直接定义在类当中的，在方法的外边
//2.成员方法不写static

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("搞学习");
    }
}

类的使用

明白下面这个例子当中

对象是stu

所用的类是Student

用stu来具体化了Student类

package com.wang.Opp.Dmeo2;

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

如何创造一个对象
1，导包，也就是指出需要使用的类在上面位置

import 包名称.类名称;
例如：
import com.wang.Opp.Demo2.Student;
对于和当前类同一个包的情况，可以省略导包语句不写

2，创建
类名称 对象名 = new 类名称（）;
Student student = new Student（）;

3，使用
（1）如何使用成员变量：对象名.成员变量名
（2）如何使用成员方法：对象名.成员方法名（参数）
 (也就是想用谁，就用对象名.谁）

 */

public class Demo2Student {
    public static void main(String[] args) {
        //1.导包
        //我想要使用的Student类与该类在同一个包下，所以省略导包语句

        //2.创建
        Student stu = new Student();

        //3.使用
        System.out.println(stu.name);
        System.out.println(stu.age);

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

        //改变对象中成员变量的数值内容
        stu.name = "小明";
        stu.age = 3 ;
        System.out.println(stu.name);
        System.out.println(stu.age);

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

        //4.使用对象中的成员方法
        stu.eat();
        stu.sleep();
        stu.study();
    }
}

类的使用之phone练习

main的主体方法：

package com.wang.Opp.Demo3;

public class Application {
    public static void main(String[] args) {
        Phone phone = new Phone();
        phone.brand="apple";
        phone.price=10000.0;
        phone.color="gary";
        System.out.println(phone.brand);
        System.out.println(phone.price);
        System.out.println(phone.color);

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

        phone.call("乔布斯");//给who赋值 同时也能运行出来
        phone.sendMessage();
    }
}

注意在调用类里面的成员方法时，对里面变量赋值，也得到直接的结果

phone类：

package com.wang.Opp.Demo3;

/*定义一个类来表示手机的事物

属性：品牌,价格，颜色
行为：打电话，发短信

对应到类中
成员变量（属性）
成员方法（行为）
 */

public class Phone {

    String brand;//品牌
    double price;//价格
    String color;//颜色

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

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

main方法：

package com.wang.Opp.Demo3;

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

        pra(phone);//phone就是Phone类型 所以phone赋值给了pra

    }

    //这个类里面的参数就是Phone类型
    public static void pra(Phone pra){
        System.out.println(pra.brand);
        System.out.println(pra.price);
        System.out.println(pra.color);

    }
}

Phone类：

package com.wang.Opp.Demo3;

/*定义一个类来表示手机的事物

属性：品牌,价格，颜色
行为：打电话，发短信

对应到类中
成员变量（属性）
成员方法（行为）
 */

public class Phone {

    String brand;//品牌
    double price;//价格
    String color;//颜色

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

当对象作为一个参数，传递到方法当中去时，实际上传递进去的是对象的地址值。

使用对象类型作为方法的返回值

main方法：

package com.wang.Opp.Demo3;

public class Demo4 {
    public static void main(String[] args) {
        Phone one = method();
        System.out.println(one.brand);
        System.out.println(one.price);
        System.out.println(one.color);
    }

    public static Phone method(){
        Phone phone = new Phone();
        phone.brand="苹果";
        phone.price=8388.0;
        phone.color="玫瑰金";
        return phone;
    }
}

Phone类：

package com.wang.Opp.Demo3;

/*定义一个类来表示手机的事物

属性：品牌,价格，颜色
行为：打电话，发短信

对应到类中
成员变量（属性）
成员方法（行为）
 */

public class Phone {

    String brand;//品牌
    double price;//价格
    String color;//颜色

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

当使用对象类型（也就是类）作为方法的返回值时，返回值其实就是对象的地址值。

局部变量和成员变量的不同

package com.wang.Opp.Demo4;

/*
成员变量和局部变量的差别

1，定义的位置不同
局部变量在方法内部定义 而成员变量在类中方法外部定义

2，作用范围不一样
局部变量：在该方法当中使用，出了方法不能用
成员变量：整个类都可以用

3.默认值不同
局部变量：无默认值，必须手动赋值
成员变量：存在默认值

4，内存的位置不同（了解）
局部变量：位于栈内存
成员变量：位于堆内存

5.生命周期不一样（了解）
局部变量：随着方法进栈而诞生，随着方法出栈而消失
成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失

 */

public class Demo4 {
    String name;//成员变量
    public void methodA(){
        int num=20;//局部变量
        System.out.println(num);
        System.out.println(name);
    }

    public void methodB(int param){//方法的参数是局部变量
        //参数在方法调用时必然会被赋值的。所以在此时不会报错
        System.out.println(param);

        int age;
        //System.out.println(num);//错误写法，num是局部变量，只能在当前的方法使用
        System.out.println(name);//成员变量全局可用
        //System.out.println(age);错误写法，age是局部变量，必须赋值否则无法使用
    }
}

面向对象三大特征之封装性

方法是一种封装

package com.wang.Opp.Demo4;

/*
面向对象三大特征：封装，继承，多态

封装性在Java当中的体现：
1.方法就是封装性
2.关键是private也是一种封装

封装就是将一些细节信息隐藏起来，对于外界不可见;
 */
public class Method {
    public static void main(String[] args) {
        int[] a = {10,20,30,40,50};
        System.out.println("最大值是："+max(a));
    }
    //求数组最大值
    public static int max(int[] a){
        int Max = a[0];
        for (int i = 0;i<a.length;i++){
            if (a[i]>Max){
                Max = a[i];
            }
        }
        return Max;
    }
}