java-第一阶段-Day08-面向对象+封装

一、面向对象

（一）面向对象的概述

        1.面向对象的概述

        Java语言是一种面向对象的程序设计语言，而面向对象思想是一种程序设计思想， 我们在面向对象思想的指引下，使用Java语言去设计、开发计算机程序。

        面向过程:有一一个需求实现，我怎么去实现，强调的是做事的步骤，需要自己一步-步的去操作实现。

        面向对象:对象泛指现实中-切事物，每种事物都具备自己的属性和行为。面向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算机事件的设计思想。

        面向对象强调的是对象强调是解决问题的主体(谁).也就是谁来解决这个问题.我们把一些属性和行为封装到这个主体中，将来你需要解决的问题,不需要自己去做去找能解决这个问题的主（对象);

        面向对象区别于面向过程思想，有一个需求实现，解决，谁来帮我实现，强调的是通过调用对象的行为来实现功能，而不是自己-步-步的去操作实现。

        面向过程是面向对象基础.面向对象是面向过程的升华。

        2.区别：

        面向过程：强调步骤，自己动手完成（亲力亲为）

        面向对象：强调对象，把功能封装到对象中。

        3.面向对象的好处

        1）更符合人类的做事思想

        2）复杂的事情简单化

        3）由执行者变为指挥者

        4.面向对象的特征

        1）封装

        2）继承

        3）多态

（二）类和对象

        1.类的概述

        类是一组相关属性和行为的集合，具有相同特征和行为事物的抽象就是类(把具备了相同特征

和相同行为的很多事物抽取出来用一个名词描述，这个名词就是类)

        属性(特征:一个事物的特征一类事物与生就具备的一些数据都是一些名词，往这类事物 上贴的标签.

        行为:一个事物可以做功能(方法)

        实际生活中:人类

                属性:描述一类事物的状态信息姓名， 性别，身高，体重，学历，身份证号

                行为:描述该事物能够做什么，吃饭，睡觉，打飞机打手枪,玩游戏

        学生

                属性:分数,学科,学历，学号

                行为:考试 上课 上自习 逃课 作弊

        2.对象的概述

        对象是一类事物的具体体现

        对象是类的一个实例，必然具备该类事物的属性和行为。

        3.类和对象的关系

        ·类是对一类事物的描述，是抽象的，看不见摸不着的。

        ·对象是一类事物的实例，是具体的，看的见摸得着

        ·类是对象的模板，对象是类的实体，没有类就没有对象

（三）Java中类的定义

        1.概述：Java中类的定义其实就是使用代码对事物描述的一种体现，使用关键字class定义，并具有固定的格式。

        2.格式：

        修饰符 class 类名{

                成员变量1；

                 成员变量2；

                 ......

                 成员方法1；

                成员方法2；         

                ......

        }

        3.类中的内容

        属性：

        对事物特征的描述体现java代码中使用变量体现称为成员变量

        行为：

                方法

        定义一个类的步骤

        1）设计类名

        2）设计类应该定义的属性

        3）设计类应该具备的行为

        示例：

public class Person {
    public String name;
    public String sex;
    public int age;
    public void eat(String food){
        System.out.println("吃"+food);
    }
    public void sleep(){
        System.out.println("睡觉");
    }
    public void talk(){
        System.out.println("说话");
    }
}

public class UsePerson {
    public static void main(String[] args) {
        Person p = new Person();
        //获取成员变量
        //变量名 = 对象名.成员变量名；
        String n = p.name;
        String s = p.sex;
        int a = p.age;
        //成员变量不赋值有默认值
        System.out.println(n);//null
        System.out.println(s);//null
        System.out.println(a);//0
        //修改成员变量值
        //对象名.成员变量 = 新值；
        p.name = "张三";
        p.sex = "男";
        p.age = 23;
        System.out.println(p.name);
        System.out.println(p.sex);
        System.out.println(p.age);
        //调用成员方法
        //对象名.方法名（）；
        p.eat("烩面");
        p.sleep();
        p.talk();
    }
}

（四）对象的使用

        1.创建对象

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

        例如：Person p = new Person();

        2.成员的使用

        获取成员变量值：

        变量 = 对象名.成员变量名；

        修改成员变量值：

        对象名.成员变量 = 新值；

        访问（调用）成员方法：

        对象名.成员方法（）；

        成员变量和成员方法都属于对象，所以都是使用对象名访问的

对象使用练习：

代码：

public class Student {
    public String name;
    public int id;
    public void study(){
        System.out.println("好好学习，天天向上");
    }
}

public class Test {
    public static void main(String[] args) {
        Student s = new Student();
        System.out.println(s.name);
        System.out.println(s.id);
        s.name = "张三";
        s.id = 123456;
        System.out.println(s.name);
        System.out.println(s.id);
        s.study();
    }
}

二、匿名对象的使用

        概述：

        没有名称的对象就是匿名对象，也就是没有定义一个对象名储存这个对象

        格式：

        new 类名（）； 例：new Person（）；

        特点：

        只能使用一次，只能在创建的时候使用。

        使用场景：

        1.调用成员方法

        2.作为方法的实际参数

        3.作为方法的返回值

        代码上的体现：简化了代码

public class UsePhone2 {
    public static void main(String[] args) {
        //调用成员变量
        new Phone().sendMessage();
        usePhone(new Phone());
        Phone p = buyPhone();
    }
    public static void usePhone(Phone p){
        p.sendMessage();
    }
    public static Phone buyPhone(){
        return new Phone();
    }

}

三、成员变量和局部变量的区别

●定义位置不同

。成员变量:类中方法外,也就是直接定义在类后的大括号中

。局部变量:方法中

●内存位置不同

。成员变量:堆空间对象在堆内存中开辟空间，成员属于对象.

。局部变量:栈空间局部变量属于方法方法进栈，因此局部变量也会在栈内存开辟空间

●生命周期不同(存活时间，从生到死过程)

。成员变量:随着类对象的创建而创建，随着对象的消失而消失(垃圾回收机制: go)

。局部变量:随着所在方法的执行而创建，随着方法的执行完毕而消失

●默认值不同

。成员变量:有默认值，即使没有手动赋值，也能使用

。局部变量:没有默认值,不赋值不能使用

public class Boy {
    public int age=10;
    public void b(){
        int a=20;
        int b;
        System.out.println(a);
    }
}

四、封装

（一）private关键字

        1.概述

        是一个关键字，是私有的含义，可以用来修饰java元素（类，方法、成员变量）

        2.修饰内容

        ·修饰成员变量

        ·修饰成员方法

        ·修饰构造方法

        ·修饰内部类

        3.修饰效果

        只能在本类中直接使用，出了这个类在外界都不能直接通过对象名访问了

（二）getter&setter方法

        1.概述：

        getter方法和setter方法时对属性封装后对外提供的统一访问属性的访问方式

        2.作用：

        getxxx():获取封装属性的值

        setxxx():修改封装属性的值

public class Girl {
    private int age;
    private String name;
    private String sex;
    public void setAge(int age){
        if(this.age>120||this.age<0){
            System.out.println("年龄不合法");
            return;
        }
        this.age=age;
    }

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getSex() {
        return sex;
    }

    public void show(){
        System.out.println(name+"*****"+age+"******"+sex);
    }
}

 

public class UseGirl {
    public static void main(String[] args) {
        Girl g = new Girl();
        g.setAge(18);
        g.setName("小红");
        g.setSex("女");
        System.out.println(g.getAge());
        System.out.println(g.getName());
        System.out.println(g.getSex());
        g.show();
    }
}