Java 初学 day05

Java day 05

1、面对对象

1、面对对象和面对过程的区别

面对过程思想：代表语言 C语言 功能开发中的每一步都是自己参与的

面对对象思想：代表语言 Java语言 指的是不断创建对象，指挥对象完成事情的思想

2、举例生活中的例子

​ 接水：

​ 面对过程思想：自己拿水杯，自己走到饮水机前，自己接水。

​ 面对对象思想：让别人拿水杯，让别人走到饮水机前，让别人接水。

3、伪代码

//需求：将大象装进冰箱

//面对过程思想:
class Demo{
    public static void main(String[] args){
        //打开冰箱门
        
        //大象跳进冰箱
        
        //关闭冰箱门
    }
}



//面对对象思想：
/*
1、都有哪些事物？
	判断事物的方法：
		1）UML课程知识
		2）名词提取法
			大象，冰箱，测试类

2、事物中都有什么？
	大象：
		属性：身高，体重，性别......
		行为：跳进冰箱，吃饭，睡觉......
	冰箱：
		属性：颜色，容量，大小......
		行为：打开冰箱门，关闭冰箱门......
	测试类：
		main方法
		
3、事物和事物之间是什么关系？
	在测试类中创建大象对象和冰箱对象
*/
class 大象{
    //属性
    身高;
    体重;
    性别;
    
    //行为
    跳进冰箱(){
        ....
    }
    
    吃饭(){
        ....
    }
    
    睡觉(){
        ....
    }
}

class 冰箱{
    //属性
    颜色;
    容量;
    大小;
    
    //行为
    打开冰箱门(){
        .....
    }
    
    关闭冰箱门(){
        ....
    }
}



class test{
    public static void main(String[] args){
        //创建一个大象对象
        //创建一个冰箱对象
        //调用冰箱对象中的打开冰箱门的方法
        //调用大象中跳进冰箱的方法
        //调用冰箱对象中的关闭冰箱门的方法
    }
}

4、类和对象的关系

类：相当于图纸

对象：相当于通过图纸造出来的一辆车

5、面对对象的三大特征

封装、继承、多态

代码案例

import java.util.Scanner;


/*
    学生：                      class Student：
        属性：姓名，年龄，性别          成员变量：name,age,gender
        行为：吃饭，睡觉               成员方法：eat(){},sleep(){}

 */
public class Student {
    //成员变量，定义在类中方法外
    String name;
    int age;
    String gender;

    //成员方法
    public void eat() {
        System.out.println("吃饭");
    }

    public void sleep() {
        System.out.println("睡觉");
    }
}
//这个类里不需要有main方法的,因为这个类只是用来描述student的属性行为的

class Demo1 {//再写一个类,要创建对象啦!!再一个类!
    
    public static void main(String[] args) {
        //创建一个学生对象
        //如何通过一个类创建一个对象
        // 语法格式：类名 对象名 = new 类名();
        //new在这里创建了一个新对象
        Student s1 = new Student();
        //获取对象中的成员变量
        //对象名.成员变量名
        String n1 = s1.name;
        System.out.println("姓名：" + n1);
        s1.name = "江川";
        System.out.println("姓名：" + s1.name);

        //如何使用对象中的成员方法
//        eat();
        //对象名.成员方法名()
        s1.eat();
        s1.sleep();
    }
}

​

6、private关键字

	我们按照今天说的类和对象的知识，创建了一个Person对象，并且也成功赋值了姓名和年龄。但是我们可以赋值一些不合实际的数值，这是不应该出现，所以我们应该在赋值之前，要先判断一下要赋的值是否合理。既然是加判断，就不是一句话可以搞定的，我们可以定义一个方法，使用方法对成员变量赋值
    我们确实可以通过加一个方法来对成员变量进行赋值，但是谁规定了我必须要用这个方法呢？我们依旧可以使用原来的方式进行赋值，我们如果可以通过一些手段，让外界无法直接获取成员变量，这样就不得不使用方法进行赋值了。
    java提供一个关键字给我们使用：private 私有的


private：
可以修饰成员变量，成员方法，构造方法
在同一个类中，private关键字不起作用，相当于透明，同一个类中被private关键字修饰的成员可以随意访问

说到现在，其实说的就是面对对象编程的三大特征之一：封装

封装：使用private关键字将类中细节进行隐藏，只对外提供公共的访问方式。

一个标准类的写法：最终是4.0版本

​ 1.0版本：使用private关键字修饰成员变量

	类：
		成员变量：使用private关键字修饰
		成员方法：针对每一个成员变量提供对应公共的setXxx()和getXxx（）

class Person {
    private String name;
    private int age;

    public String getName(){
        return name;
    }

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

    public int getAge(){
        return age;
    }

    public void setAge(int i) {
        if (i > 0 && i <= 130) {
            age = i;
        }else {
            System.out.println("输入的年龄不合实际！");
        }
    }

    private void fun1(){
        System.out.println("好好学习，天天向上！");
    }

    public void show1(){
        fun1();
    }
}

public class PersonDemo {
    public static void main(String[] args) {
        //创建一个Person类的对象
        Person p1 = new Person();
//        System.out.println("姓名：" + p1.name);
//        System.out.println("年龄：" + p1.age);
        System.out.println("姓名：" + p1.getName());
        System.out.println("年龄：" + p1.getAge());
        System.out.println("-------------------------");
//        p1.name = "江川";
//        p1.age = 1800;
        p1.setAge(1800);
        p1.setName("江川");
//        System.out.println("姓名：" + p1.name);
//        System.out.println("年龄：" + p1.age);
        System.out.println("姓名：" + p1.getName());
        System.out.println("年龄：" + p1.getAge());
        System.out.println("------------------------");
//        p1.fun1();
        p1.show1();
    }
}

补充：

匿名对象

//匿名对象，指的是没有名字的对象，只能用一次，后续无法继续使用该对象

d1.method(new Teacher());//new Teacher() 就是一个匿名对象

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

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

形式参数
当今后看到类做参数时候，调用时需要传入该类的对象【或者该类的字对象】