Java-11 面向对象

一、面向对象和面向过程的区别：

1.面向过程：强调的是每个功能的实现步骤 （参与者）

2.面向对象：强调的是对象，然后由这个对象去调用方法 （指挥者）

import java.util.Arrays;

public class ObjectDemo {
    public static void main(String[] args) {
        //面向过程
        int[] arr={1,5,8,15,15,7};
        System.out.print("[");
        for (int i=0;i<arr.length;i++){
            if (i==arr.length-1){
                System.out.println(arr[i]+"]");
            }else{
                System.out.print(arr[i]+",");
            }

        }
        System.out.println("=======面向对象=========");
        System.out.println(Arrays.toString(arr));//面向对象一行代码遍历数组
    }
}

二、面向对象的特点

　　面向对象思想是一种更符合我们思考习惯的思想，它可以将复杂的事情简单化，并将我们从执行者变成了指挥者，面向对象的语言中，包含了三个基本特征，即封装，继承和多态

三、类和对象

　　3.1 类：是一组相关属性和行为的集合

　　　  属性：就是该事物的状态信息

　　　  行为：就是该事物能做什么

举例：小猫

 　　　属性：名字。体重，颜色，年龄

　　     行为：走，跑，跳

　　3.2 什么是对象

　　　　　　对象是一类事物的具体表现，对象是类的一个实例，并且具备该类事物的属性和行为

　　3.3 类和对象的关系

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

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

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

　　3.4 类的定义

　　　　注意事项：1.成员变量直接定义在类中，在方法外边

　　　　　　　　　2.成员方法不要写static

package com.shujia.day1;

/*
定义一个类，用来模拟“学生”事物，其中就有两个组成部分
属性：（是什么）
    姓名
    年龄
行为；（做什么）
    吃饭
    学习
对应Java的类中
成员变量（属性）：格式 数据类型 变量名；
    例：String name；
        int age；
成员方法（行为）：
    public void eat()  //吃饭
    public void sleep() //睡觉

通常情况下，一个类不能直接使用，需要根据类创建一个对象，才能使用
1.导包    也就是指出需要使用的类，在什么位置
格式： import 包名称.类名称
对于和当前类属于同一个包的情况，可以省略导包语句不写
2.创建
格式： 类名称 对象名 = new 类名称();
Student stu = new Student();
3.使用
3.1 使用成员变量 对象名.成员变量名
3.2 使用成员方法 对象名.成员方法名（参数）
 */
class Student1 {
    String name;
    int age;

    public void eat() {
        System.out.println("吃饭");
    }

    public void sleep() {
        System.out.println("睡觉");
    }

    public void study(String what) {
        System.out.println("学"+what);
    }
}

public class ObjectDemo1 {
    public static void main(String[] args) {
        //1.导包
        //我需要使用的Student1类，和我的字ObjectDemo位于同一包下，所以省略不写
        //2.创建
        Student1 stu =new Student1();
        //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("数学");//学数学
    }
}

　　3.5 一个对象的内存图

　　3.6 对象类型作为方法的参数返回

package com.shujia.day1;

class Phone {
    String brand;
    double price;
    String color;
    public void call(String name){
        System.out.println("打电话给"+name);
    }
    public void sendMessage(){
        System.out.println("群发消息");
    }
}


public class PhoneDemo {
    public static void main(String[] args) {
        Phone one = new Phone();
        System.out.println(one.brand);
        System.out.println(one.price);
        System.out.println(one.color);
        one.call("马云");
        one.sendMessage();
        one.brand="小米";
        one.price=2999;
        one.color="陶瓷白";
        methon(one);
        //对象类型作为参数有返回值方法调用
        Phone two =getPhone();
        System.out.println(two.brand);
        System.out.println(two.price);
        System.out.println(two.color);


    }
//当一个对象作为参数传递到方法中，实际上传递进去的的是地址值
    //无返回值类型
    public static void methon(Phone pargm){
        System.out.println(pargm.brand);//小米
        System.out.println(pargm.price);//2999
        System.out.println(pargm.color);//陶瓷白
    }
    //有返回值类型 当使用对象类型作为方法的返回值时；返回值其实是对象的地址值
    public static Phone getPhone(){
        Phone one = new Phone();
        one.brand="mi";  //mi
        one.price=1999;  //1999
        one.color="白";//白
        return one;
    }
}

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

　　　　1.在类中的位置不同 　

　　　　　　成员变量： 类中方法外

　　　　　　局部变量： 方法内或者方法声明上

　　　　2.在内存中的位置不同

　　　　　　成员变量： 堆内存

　　　　　　局部变量： 栈内存

　　　　3.生命周期不同

　　　　　　成员变量： 随着对象的存在而存在，随着对象的垃圾回收而消失

　　　　　　局部变量： 随着方法的进栈而存在，随着方法的出栈完毕而消失

　　　　4.初始化值不同

　　　　　　成员变量： 有默认的初始化值

　　　　　　局部变量： 没有默认的初始化值，必须先定义，赋值，才能使用。

　　　　5.作用范围不一样　　　

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

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

package com.shujia.day1;

class Student {
    String name;//成员变量
    public void method(){
        int num=0;//局部变量
        System.out.println(num);
    }
    public void methodB(int pargram){ //方法参数是局部变量
        int age;
        System.out.println(pargram);//方法被调用时一定会被赋值
//        System.out.println(num);错误写法
//        System.out.println(age);错误写法，没有赋值不能用
        System.out.println(name);//null
    }
}

四、面向对象三大特征

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

　　　　封装性在Java中的表现：1.方法就是一种封装

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

//方法封装
public class ArrayDemo1 {
    public static void main(String[] args) {
        //调用最大值
        int max = maxNum(new int[]{2,5,4,6,4,8,5,9});
        System.out.println("数组最大值是"+max);
        //调用最小值
        int min =minNum(new int[]{2,5,4,6,4,8,5,9});
        System.out.println("数组最小值是"+min);
    }

    //有返回值，输出数组最大值
    public static int maxNum(int[] arr){
        int max = arr[0];
        for (int i=1; i<arr.length; i++){
            if(arr[i]>max){
                max = arr[i];
            }
        }
        return max;
    }

    //有返回值，输出数组最大值
    public static int minNum(int[] arr){
        int min = arr[0];
        for (int i=1; i<arr.length; i++){
            if(arr[i]<min){
                min = arr[i];
            }
        }
        return min;
    }

　　private封装

package com.shujia.day1;
//关键字private封装
/*
问题描述;定义年龄的时候，无法阻止不合理的数据录入进来
解决方案：用private关键字将需要保护的成员变量进行修饰

注意事项：一旦使用private进行修饰，那么本类当中可以随意使用
但是超出本类不能直接访问

间接访问private成员变量方法：就是定义一对getXxx/setXxx方法
特例：Boolean型不使用getXxx，使用isXxx
setter：必须有参数无返回,参数类型与成员变量对应
getter：必须没有参数有返回值，返回值类型和返成员变量对应
 */
class Person{
    String name;
    private int age;
    public void show(){
        System.out.println("我的名字是"+name+"我的年龄"+age);
    }
    //其他类不能直接访问age，设置间接访问age方法
    public void setAge(int num){
        if (num<=150 && num>0){
            age = num;
        }else {
            System.out.println("输入数据违法");
        }
    }
    //这个成员方法，专门私语获取age数据
    public int getAge(){
        return age;
    }
}

public class PersonDemo {
    public static void main(String[] args) {
        Person p = new Person();
        p.show();//我的名字是null我的年龄0
//      p.age;//使用private，超出本类不能直接访问
        p.name="阿伟";//直接访问
        p.setAge(10);//间接访问
        p.getAge();
        p.show();//我的名字是null我的年龄0
                 //我的名字是阿伟我的年龄10
        p.name="张三";
        p.setAge(-10);//间接访问
        p.getAge();
        p.show();//输入数据违法
                 //我的名字是张三我的年龄10

    }
}

　　2.this关键字

package com.shujia.day1;
/*
当方法的局部变量和类的成员变量重名的时候，根据"就近原则"，优先使用局部变量
如果需要访问本类当中成员变量，需要使用格式
this.成员变量名
作用;重名的情况下起到区分的效果

"通过谁调用的方法谁就是this"  这里this==people
 */
class People{
    String name;
    public void sayHello(String who){
        System.out.println(who + "你好，我是"+name);
    }
    public void sayHello1(String name){
        System.out.println(name + "你好，我是"+name);
    }
    public void sayHello2(String name){
        System.out.println(name + "你好，我是"+this.name);
        System.out.println(this);//com.shujia.day1.People@4554617c
    }
}



public class ThisDemo {
    public static void main(String[] args) {
        People people = new People();
        people.name = "王健林";
        people.sayHello("王思聪");//王思聪你好，我是王健林
        people.sayHello1("王思聪");//王思聪你好，我是王思聪
        people.sayHello2("王思聪"); //王思聪你好，我是王健林   people调用sayHello2(),则people就是this
        System.out.println(people);//com.shujia.day1.People@4554617c
    }
}

　　3. 构造方法

package com.shujia.day1;

/*
构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是调用构造方法
new对象就是在调用构造方法
格式：
public 类名称（参数类型 参数名称）{
    方法体
}

注意事项：
1.构造方法名称必须和所在的类名称完全一样，大小写也一样
2.构造方法不要写返回值类型，连void都不写
3.构造方法不能return一个具体的返回值
4.如果没有编写构造方法，那么编译器会默认赠送一个构造方法，方法体什么都不做
public Student3(){}
5.一旦编写一个构造方法，那么编译器不再赠送
6.构造方法也是可以重载的
 */
class Student3 {
    //成员变量
    private String name;
    private int age;
    //show方法
    public void show(){
        System.out.println("姓名:"+name+" 年龄:"+age);
    }
    //无参构造方法
    public Student3() {
        System.out.println("无参构造方法执行");
    }
    //全参构造方法
    public Student3(String name, int age) {
        System.out.println("全参构造方法执行");
        this.name = name;
        this.age = age;
    }
    //Getter Setter
    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 class MakeMethodDemo {
    public static void main(String[] args) {
        Student3 stu = new Student3();//无参构造方法执行
        System.out.println("=========================");
        Student3 stu1=new Student3("阿伟",20);//全参方法体执行
        stu1.show();//姓名:阿伟 年龄20
        System.out.println("姓名:"+stu1.getName()+" 年龄:"+stu1.getAge());//姓名:阿伟 年龄20
        System.out.println("=========================");
        //如果需要改变对象数据内容，仍然需要用setXxx  getXxx方法
        stu1.setAge(21);//改变年龄
        stu1.show();//姓名:阿伟 年龄21
        System.out.println("姓名:"+stu1.getName()+" 年龄:"+stu1.getAge());//姓名:阿伟 年龄21
    }
}

　　4.定义一个标准的类（可以使用快捷键alt+ins自动生成代码）

　　　　4.1 所有成员变量都要使用private关键字修饰

　　　　4.2 为每一个成员变量编写一对Getter/Setter方法   

　　　　4.3 编写一个无参数构造方法

　　　　4.4 编写一个有参数构造方法

package com.shujia.day1;

class BigStar {
    //成员变量
    private String name;
    private int age;

    //无参构造方法
    public BigStar() {
    }

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

    //Getter/Setter 方法
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    //show方法
    public void show(){
        System.out.println("姓名："+name+"，年龄："+age);
    }
}


public class Star {
    public static void main(String[] args) {
        BigStar star1 =new BigStar("迪丽热巴",20);
        star1.show();
        System.out.println("=====================");
        star1.setAge(22);
        star1.show();
        System.out.println("=====================");
        BigStar star2=new BigStar();
        star2.setName("古力娜扎");
        star2.setAge(20);
        star2.show();

    }
}　　

 　　5 匿名对象

package com.shujia.day1;

import java.util.Scanner;

/*
创建对象标准格式
类名称 对象名 = new 类名称();

匿名对象就是只要右边的对象，没有左边的名字和赋值运算符
格式： new 类名称();

注意事项：
    匿名对象只能使用唯一的一次，下次再用不得不再创建一个新对象
使用建议
    一个对象只要使用一次可以使用匿名对象
 */
class Annony {
    String name;

    public void showName() {
        System.out.println("我的名字是" + name);
    }
}

public class AnnonyDemo {
    public static void main(String[] args) {
        //左边one就是对象名称
        System.out.println("=======一般写法=========");
        Annony a = new Annony();
        a.name = "马儿扎哈";
        a.showName();//我的名字是马儿扎哈
        System.out.println("=========匿名对象=======");
        //匿名对象
        new Annony().name = "赵又廷";
        new Annony().showName();//我的名字是null
        System.out.println("=====scanner普通使用方式=====");
        //scanner普通使用方式
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        System.out.println(num);
        System.out.println("===匿名对象方式=======");
        //匿名对象方式
        int num1 = new Scanner(System.in).nextInt();
        System.out.println("输入的是" + num1);
        System.out.println("=====一般写法传入参数=========");
//        一般写法传入参数
//        Scanner sc = new Scanner(System.in);
        methon(sc);
        System.out.println("=====匿名对象传入参数=========");
//        匿名对象传入参数
        methon(new Scanner(System.in));
        System.out.println("=====匿名对象作为返回值=========");
//      Scanner sc = methodReturn();
        int num3 = sc.nextInt();
        System.out.println("输入的是" + num3);
    }

    //    匿名对象传入参数
    public static void methon(Scanner sc) {
        int num = sc.nextInt();
        System.out.println("输入的是" + num);

    }


    //    匿名对象作为返回值
    public static Scanner methodReturn() {
//        一般写法
//        Scanner sc =new Scanner(System.in);
//        return sc;
//        匿名对象作为返回值
        return new Scanner(System.in);
    }
}