Java面向对象1

面向对象1

面向对象思想

面向对象是基于面向过程的一种编程思想。

• 面向过程：强调的是每一个功能的步骤
• 面向对象：强调的是对象，然后由对象去调用功能

面向对象的思想特点

• 是一种符合我们思考习惯的思想
• 可以将复杂的事情简单化
• 让我们从执行者变成了指挥者

举例：洗衣服

• 面向过程：把衣服脱下来–找一个盆–放水–放洗衣粉–浸泡十分钟–揉一揉–清洗衣服–拧干–晾起来
• 面向对象：把衣服脱下来–打开全自动洗衣机–放入衣服–按下按钮–晾起来

类与对象

我们学习编程语言，其实就是为了把现实世界的事物模拟出来，实现信息化。

如何表示现实世界的事物

• 属性：事物的描述信息
• 行为：事物能做什么

Java语言最基本的组成单位是类，所以，在后面的学习过程中，我们是通过类来实线事物的。

类：是一组相关的属性和行为的集合
对象：就是该类事物的具体体现

举例：

• 类：学生
• 对象：张三

类的定义

类的定义：类是用来描述现实世界事物的

事物：

• 属性
• 行为

类：

• 成员变量
  和变量的定义是一样的，有两个小区别：
  位置不同：类中，方法外；
  初始化值：成员变量不需要给初始化值也可以使用，因为它有默认值
• 成员方法
  和方法的定义是一样的，有一个小区别。
  去掉了修饰符中static关键字

需求：定义一个学生类。

学生事物：

• 属性：姓名，年龄…
• 行为：学习，吃饭…

学生类：

• 成员变量：姓名，年龄…
• 成员方法：学习，吃饭…

public class Student {
    //成员变量
    //姓名
    String name;
    //年龄
    int age;

    //成员方法
    //学习的方法
    public void study() {
        System.out.println("好好学习天天向上");
    }

    //吃饭的方法
    public void eat() {
        System.out.println("学习饿了要吃饭");
    }
}

类的使用

类的使用：使用一个类，其实就是使用该类的成员。（成员变量和成员方法）
而我们要想使用一个类的成员，就必须先拥有该类的对象。
如何拥有一个类的对象：创建对象

创建对象格式：
		类名 对象名 = new 类名();

对象访问成员

成员变量：
		对象名.成员变量
成员方法：
		对象名.成员方法(...)

    public static void main(String[] args) {
        Student s = new Student();
        //System.out.println("s:"+s); 结果是地址值

        //使用成员变量
        System.out.println("姓名："+s.name); //null
        System.out.println("年龄："+s.age); //0

        //给成员变量赋值
        s.name = "小明";
        s.age = 30;
        //再次使用成员变量
        System.out.println("姓名："+s.name); //小明
        System.out.println("年龄："+s.age); //30

        //调用成员方法
        s.study(); //好好学习天天向上
        s.eat(); //学习饿了要吃饭
    }

练习

手机的定义和使用

手机类：
成员变量：品牌，价格，颜色…
成员方法：打电话，发短信…

public class Phone {
    //品牌
    String brand;
    //价格
    int price;
    //颜色
    String color;

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

public class PhoneTest {
    public static void main(String[] args) {
        //创建对象
        Phone p = new Phone();

        //输出成员变量的值
        System.out.println("品牌"+p.brand); //null
        System.out.println("价格"+p.price); //0
        System.out.println("颜色"+p.color); //null

        //给成员变量赋值
        p.brand = "锤子";
        p.price = 2999;
        p.color = "棕色";

        //再次输出成员变量的值
        System.out.println("品牌"+p.brand); //锤子
        System.out.println("价格"+p.price); //2999
        System.out.println("颜色"+p.color); //棕色

        //调用成员方法
        p.call("小明");
        p.sendMessage("小明");
    }
}

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

1. 在类中的位置不同
   成员变量：在类中，方法外
   局部变量：在方法中或者方法声明上（形式参数）
2. 在内存中的位置不同
   成员变量：在堆内存
   局部内存：在栈内存
3. 生命周期不同
   成员变量：随着对象的创建而存在，随着对象的消失而消失
   局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
4. 初始化值不同
   成员变量：有默认值
   局部变量：没有默认值，必须先定义，赋值，最后使用

private关键字

直接使用对象名访问成员变量，会存在数据的安全问题。
用private关键字可以实现让外界不直接访问成员变量。

private关键字：

• 是一个权限修饰符
• 可以修饰成员变量和成员方法
• 被private修饰的成员只能在本类中被访问
• 针对被private修饰的成员变量，我们会相应地给出getXxx()和setXxx()用于获取和设置成员变量的值，方法用public修饰

    //成员变量
    //姓名
    String name;
    //年龄
    //int age;
    private int age;

    public void setAge(int a) {
        if(a<0 || a>200) {
            System.out.println("你给的年龄有误");
        }else{
            age = a;
        }
    }

    public int getAge(int a) {
        return age;
    }

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

        //创建对象
        Student s = new Student();
        s.show();

        //给成员变量赋值
        s.name = "林青霞";
        //s.age = 30;
        //s.age = -30;
        //通过方法赋值
        s.setAge(-30);
        s.show();

private应用

学生类

• 成员变量用private修饰
• 提供对应的getXxx()/setXxx()方法
• 一个标准的案例使用

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

    public void setName(String n) {
        name = n;
    }

    public String getName() {
        return name;
    }

    public void setAge(int a) {
        age = a;
    }

    public int getAge() {
        return age;
    }
}

public class StudentTest {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        System.out.println(s.getName()+"***"+s.getAge());

        //给成员变量赋值
        s.setName("林青霞");
        s.setAge(30);
        System.out.println(s.getName()+"***"+s.getAge());
    }
}

封装

封装

• 封装是面向对象三大特征之一
• 封装是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改，就像年龄

封装原则：

• 把不需要对外提供的内容都隐藏起来
• 把属性隐藏，提高公共方法对其访问。
  成员变量private，提供对应的getXXX()/setXxx()方法

封装好处：

• 通过方法来控制成员变量的操作，提高了代码的安全性
• 把代码用方法进行封装，提高了代码的复用性

this关键字

如果局部变量名称和成员变量名称一致，在方法中使用的时候采用的是就近原则。
用this关键字，可以把局部变量的名称赋值给成员变量的名称。

this：代表所在类的对象引用。
方法被哪个对象调用，this就代表谁。

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

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }
}

public class StudentTest {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        System.out.println(s.getName()+"---"+s.getAge());

        //给成员变量赋值
        s.setName("林青霞");
        s.setAge(30);
        System.out.println(s.getName()+"---"+s.getAge());
    }
}

this使用场景：用于解决成员变量被隐藏的问题。

构造方法

构造方法：用于给对象的数据进行初始化

格式：

• 方法名和类名相同
• 没有返回值类型，连void都不能写
• 没有具体的返回值

public class Student {
    public Student() {
        System.out.println("这是构造方法");
    }
}

public class StudentTest {
    public static void main(String[] args) {
        //调用构造方法
        //通过new关键字
        //格式： 类名 对象名 = new 构造方法名(...);
        Student s = new Student();
    }
}

注意事项：

• 如果我们没有给出构造方法，系统将给出一个无参数的构造方法给我们使用
• 如果我们给出了构造方法，系统将不再提供默认的构造方法供我们使用。
  这个时候，我们如果还想使用无参数构造方法，就必须提供
  我们推荐：自己给出无参数构造方法
• 构造方法也是可以重载的

给成员变量赋值的方式：

• 通过setXxx()
• 通过构造方法

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

    /*
    public Student() {
        System.out.println("这是构造方法");
    }
     */

    public Student () {}

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

    public Student(int age) {
        this.age = age;
    }

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

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

public class StudentTest {
    public static void main(String[] args) {
        //调用构造方法
        //通过new关键字
        //格式： 类名 对象名 = new 构造方法名(...);
        Student s = new Student();
        s.show();

        Student s2 = new Student("林青霞");
        s2.show();

        Student s3 = new Student(30);
        s3.show();

        Student s4 = new Student("林青霞",30);
        s4.show();
    }
}

标准类的代码写法和测试

标准类案例：

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

    //构造方法
    public Student() {}

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

    //成员方法
    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 StudentTest {
    public static void main(String[] args) {
        //无参构造方法+setXxx();
        Student s = new Student();
        s.setName("林青霞");
        s.setAge(30);
        System.out.println(s.getName()+"---"+s.getAge());

        //带参构造方法
        Student s2 = new Student("林青霞",30);
        System.out.println(s2.getName()+"---"+s2.getAge());
    }
}