面向对象一（类对象）

最新推荐文章于 2022-08-25 17:09:52 发布

方大猫

最新推荐文章于 2022-08-25 17:09:52 发布

阅读量480

点赞数 2

文章标签： java

本文链接：https://blog.csdn.net/fangcatt/article/details/107889946

版权

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

之前看了一个很好的描述，我们写代码就像是做饭，面向对象就像是盖浇饭，面向过程像是蛋炒饭。盖浇饭是我们做一份米饭，炒一份菜，想吃青椒肉丝盖浇饭就把青椒肉丝这个菜放在饭上，不想吃青椒肉丝了就可以直接把青椒肉丝从饭上剥掉，放上其他的菜上就好了。面向对象也是这样，我们把所有的功能单独的拿出来，如果需要就链接起来，不需要就断开，强调的是我用谁来做。蛋炒饭是在做饭的时候就直接把所有的菜都放进去，想吃腊肠炒饭就在炒饭的时候放腊肠进去，但是如果突然不想吃了，那就得一点一点的把腊肠挑出来。面向过程也是如此，我们在写代码的时候就把所有的功能按照实现的过程依次写下去，强调的是我该怎么做，但是当我们不需要某个功能的时候，就需要花费很大力气区把这个功能剥除掉。
从上面的描述我们不难看出，面向对象的程序有高内聚，低耦合的特点，虽然前期编写的时候可能会麻烦一些，但是后期维护更简单，是线下更主流的编码方式。

面向对象的三大特征：

封装
继承
多态

抽象

抽象一种从复杂到简洁的思维方式。比如说人是一个抽象的，有鼻子，有眼睛，有头发，但是如果描述了头发是黑色的，稀疏的，眼睛是小而聚光的，那这就不是抽象的描述，而是变得具体。
对象是具体的，绝对不抽象。但是具体的东西是由抽象推演过来的。

成员变量和局部变量

方法外边的是成员变量
方法里的是局部变量

//成员变量和局部变量的区别
public class VerDemo{
	//方法外面：成员变量
	String name = "成员变量";
	public void doWork(){
		//方法里边：局部变量
		String name2 = "局部变量";
	}
}

初始值：
当没有对变量进行赋值时，也就是没有初始化的时候，成员变量时直接就有初始值的，但是局部变量没有初始值。
初始值数据
作用域：
成员变量在当前类中都可以用；
局部变量在所属的{}中可以使用；

生命周期：
成员变量：是属于对象的，存储在堆内存中，随着对象的销毁而销毁。
局部变量：是属于方法的，存储在栈内存中，随着定义方法的调用结束而销毁。

类（class）

是对某一类事物的抽象描述（状态和行为）。
类可以看做是对象的数据类型。就好比无论你是谁，只要是女人，那么你的类型就是女人。
类是拥有特性（状态（变量））和行为（功能（方法））的多个对象的抽象。
定义语法格式：

public class 类名 {
	//可编写0到n个成员变量
	[修饰符] 数据类型 变量名1;
	[修饰符] 数据类型 变量名2;

	//可编写0到n个成员方法
	[修饰符] 返回值类型 方法名称{
		方法体;
	}
}

例：

public class Person {
    //状态：成员变量
    //成员变量是属于对象的，所以应该是先有对象，才有成员变量
    String name;
    int age;
    //行为：成员方法
    void say(){
        System.out.println("我是"+ name + "，我的年龄" + age
        );
    }
}

对象（object）

具体的类的体现。也称之为实例。
就是类中没有具体的数据，对象可以让类有具体的值。
定义语法：
类名对象变量名 = new 类名（）；
调用语法：
对象名.方法名（）;

public class Test {
    public  static void main(String[] args){
        //创建对象
        //语法：类名 对象变量名 = new 类名();
        Person p = new Person();
        //调用对象的方法
        //语法：对象名.方法名();
        p.say();
    }
}

对象的操作

创建对象
语法：
类名对象变量名 = new 类名（）；
直接打印对象的时候，打印的是类似于数组一样的地址值。
匿名对象：
语法：new 类名；
只能再引用的时候使用一次。
对象操作字段
1.给字段设置数据
对象变量名.字段名 = 值；
2.获取字段数据
数据类型变量名 = 对象变量名.字段名；
对象调用方法
对象变量名.方法（参数）；

public class Test {
    public  static void main(String[] args){
        //创建对象
        //语法：类名 对象变量名 = new 类名();
        Person p = new Person();

        //为变量赋值
        p.name = "fangyuan";
        p.age = 20;
        
        String name  = p.name;
        int age = p.age;
        System.out.println(name);
        //调用对象的方法
        //语法：对象名.方法名();
        p.say();
    }
}

内存分析图：

构造器

构造器。也称为构造方法，用来创建对象和给对象做初始化。
语法：

[public] 类名 （参数）{
//方法体
}

注意：

构造器名称和类名相同
没有返回值类型
构造器中不能使用return语句
如果一个类中没有手动添加构造器，那么就会有一个默认的无参的构造器，类如果有public，那么类默认构造器就有public，如果类没有，那么类里边默认的构造器就没有。

作用：
初始化对象，最终得到一个对象。

public Person(){
        System.out.println("无参构造器");
    }

有参构造器
在创建对象的同时，为成员变量赋值

public class Person {
    int age ;
    String name;
    public Person(String n,int a){
        name = n;
        age = a;
    }
}



public class ConstrutorDemo {
   public static void main(String[] args){
      //使用构造器创建对象
       Person p = new Person();
      //为成员变量赋值
       p.name = "xxx";
       p.age = 20;

       //使用有参构造器创建对象并初始化成员变量
       Person p2 = new Person("yyy",20);
       System.out.println(p2.name);
       System.out.println(p2.age);
   }
}

注意：
当自己创建了一个新的构造器的时候，默认的就会消失，要是还想用就需要自己手动添加上。

封装思想

封装是面向对象三大特征之一，其含义有两个：

把对象的字段和方法存放在一个独立的模块（类）中
信息隐蔽，尽可能隐藏对象的数据和功能的细节

封装的好处

保证数据的安全性，防止调用者随意修改数据
提高组件的重用性，把公用功能放到同一个类中，谁需要该功能，直接调用即可

访问修饰符

（重点）javaBean规范
javaBean是一种符合某些条件特殊类，但是必须遵循一定的规范：

类必须是public 修饰
必须保证有公共无参构造器
字段必须使用private修饰，每个字段提供一对getter和setter方法

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

    //为age提供外界获取值的方法
    public int getAge(){
        return age;
    }

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

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


    void doWork(){
        System.out.println(name+age);
    }
}

public class JavaBeanDemo {
    public static void main(String[] args){
        Person p = new Person();
        //可以随意的为age赋值
        //p.age = 10;
        //使用javaBean后
        p.setAge(10);

        //可以随意的获取age的值
        //System.out.println(p.age);
        //使用javaBean后
        System.out.println(p.getAge());
    }
}

练习

类的定义

需求：描述猫类

步骤：

（1）猫有名字、年龄等状态

（2）说话的功能

定义测试: CatDemo.java

需求：作为Cat类和对象的测试类

步骤：

（1）创建Cat对象c

（2）使用c对象调用说话方法

（3）给对象成员变量设置值

（4）再使用c对象调用说话方法，观察成员变量的值的改变

（5）获取c对象的成员变量

作业目的：掌握类的定义的语法。

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

    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;
     }

     void say(){
         System.out.println("喵喵"+name+"喵喵喵"+age);
     }
}

public class CatDemo {
    public static void main(String[] args){
       //创建Cat对象c
        Cat c = new Cat();
        //使用c对象调用说话方法
        c.say();
        //给对象成员变量设置值
        c.setAge(5);
        c.setName("咪咪");
        //再使用c对象调用说话方法，观察成员变量的值的改变
        c.say();
        System.out.println(c.getAge());
        System.out.println(c.getName());
    }
}

运行结果
练习一结果
2. 构造器和对象的创建

需求：描述猫类

步骤：

（1）猫有名字、年龄等状态

（2）无参构造器

（3）带参数构造器初始化名字和年龄两个字段

（4）说话的功能

定义测试类: CatDemo.java

需求：作为Cat类和对象的测试类

步骤：

（1）使用无参数构造器创建对象c1并初始化c1的成员变量

（2）使用带参构造器创建对象c2同时初始化成员变量，并调用说话方法

作业目的：掌握构造器的定义和使用构造器创建对象，通过两种不同方式创建对象, 理解有参数和无参数构造器的区别

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

    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;
    }

    //无参构造器
    public Cat(){}

    //带参数构造器初始化名字和年龄两个字段
    public Cat(String name,int age){
        this.name = name;
        this.age = age;
    }

    void say(){
        System.out.println("喵喵"+name+"喵喵喵"+age);
    }
}

public class CatDemo {
    public static void main(String[] args){
        //使用无参数构造器创建对象c1并初始化c1的成员变量
        Cat c1 = new Cat();
        c1.setName("miaomimi");
        c1.setAge(6);
        c1.say();

        //使用带参构造器创建对象c2同时初始化成员变量，并调用说话方法
        Cat c2 = new Cat("mimi",3);
        c2.say();
    }
}

运行结果
练习2结果
3. JavaBean规范

需求：定义一个符合JavaBean规范的学生类

作业要求：

（1）学生有姓名、年龄两个字段

（2）符合JavaBean规范

定义测试类: StudentDemo.java

需求：作为Student类和对象的测试类

步骤：

（1）创建学生对象

（2）使用setter方法设置值

（3）获取对象成员变量的值

（4）通过有参数构造器创建对象并使用setter方法修改值

作业要求：

（1）掌握JavaBean规范的四个步骤

（2）理解使用setter方法和构造器之间初始化字段的区别

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

    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;
    }

    public Student(){}

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

    void say(){
        System.out.println("my name is "+name+"I`m "+age+"years old");
    }
}

public class StudentDemo {
    public static void main(String[] main){
       //创建学生对象
        Student student = new Student();
        //使用setter方法设置值
        student.setName("方园");
        student.setAge(20);

        //获取对象成员变量的值
        System.out.println(student.getName());
        System.out.println(student.getAge());

        //通过有参数构造器创建对象并使用setter方法修改值
        Student student1 = new Student("仙女",18);
        student1.say();
        student1.setAge(16);
        student1.say();
    }
}

运行结果
练习3结果

综合练习

1.练习一

1、阅读信息卡，完成要求：

1>根据信息卡信息，定义一个学生类(Student)，然后实例化 张三，李四 2个对象。

2>使用javabean规范做.

为成员变量赋值：

1.构造器（知道元素）

2.set方法（不知道元素）

对象信息:

姓名(name)：张三

年龄(age) ：18

性别(gender)：男

英语(enScore)：90

数学(mathScore)：135

语文(cnScore)：105

姓名(name)：李四

年龄(age) ：20

性别(gender)：女

英语(enScore)：130

数学(mathScore)：100

语文(cnScore)：125

public class Student {
    private String name,gender;
    private int age,enScore,mathScore,cnScore;

    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getGender(){
        return gender;
    }
    public void setGender(String gender){
        this.gender = gender;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        this.age = age;
    }
    public int getEnScore(){
        return  enScore;
    }
    public void setEnScore(int enScore){
        this.enScore = enScore;
    }
    public int getMathScore(){
        return mathScore;
    }
    public void setMathScore(int mathScore){
        this.mathScore = mathScore;
    }
    public int getCnScore(){
        return cnScore;
    }
    public void setCnScore(int cnScore){
        this.cnScore = cnScore;
    }

    public Student(){}

    public Student(String name,int age,String gender,int enScore,int mathScore,int cnScore){
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.enScore = enScore;
        this.mathScore = mathScore;
        this.cnScore = cnScore;
    }

    void say(){
        System.out.println("姓名="+name+" 年龄="+age+" 性别="+gender+" 英语="+enScore+" 数学="+mathScore+" 语文="+cnScore);
    }
}

public class StudentDemo {
    public static void main(String[] args){
        Student student = new Student("张三",18,"男",90,135,105);
        student.say();

        student.setName("李四");
        student.setAge(20);
        student.setGender("女");
        student.setEnScore(130);
        student.setMathScore(100);
        student.setCnScore(125);
        student.say();
    }
}