零基础学习java------day7------面向对象

1. 面向对象

1.1 概述

面向过程：c语言

面向对象：java ；python；C++等等

面向对象的概念：

（万物皆对象）------think in java   everything  in an  object

把现实中的事务抽象成由一系列属性和行为组成的结构体（类），每个结构体都有属于自己的功能，在软件开发的过程中，通过对不同功能的结构体进行组合，完成整个软件功能。且结构体可服用

例如;  若要将现实中的飞机抽象成一个对象

首先你要先定义一个飞机类（看到这个名字就知道是飞机），其次飞机的一些特征如有轮子，有机翼等，这些特征在抽象类中（即类中的代码中）怎么体现出来呢，这时我们就需要在类中定义一些属性来表示现实中飞机的这些特性。好了，一个飞机的固有属性描述完了。但是，其能飞的行为又该怎么来描述呢？这时就需要在类中定义一个‘’飞‘’的方法去表示飞机会飞的行为，飞机的其他行为，如加速减速都需要在类中定义方法去描述。当调用这些方法时，表示的就是飞机对应的行为（如，当调用“飞”方法时，表示的就是飞机飞的行为）。若是不同的飞机类型（如，歼-20，歼-10）该怎么表示呢？这里的话对象就起作用了，这里我们使用airplane1表示飞机歼-20，airplane2表示飞机歼-10，当用airplane1对象调用”飞”方法时，表示的是歼-20飞行的行为，当用airplane2对象调用“飞”方法时，表示的是歼-10飞行的行为。

OO: object-oriented    面向对象

　　ooa：面向对象的分析

　　ood：面向对象的设计

　　oop：面向对象的编程（program）

软件的生命周期：

　　需求分析，概要设计，详细设计，系统开发，系统测试，部署，运行和维护

需求：

　　存储全班同学的信息（姓名，性别，分数）

　　最直观的想法：利用3个数组去分别存储姓名，性别，分数，但这样不便于查找某个学生的性别和分数

　　所以就需要一种类型能够将姓名，性别，和分数聚合到一起，那就使用一种自定义的类型-------类

1.2 三大特征

封装       继承       多态        （抽象）　　

1.3 类和对象的关系

类：一种（引用）数据类型，自定义的一种数据类型

对象：具体存在的事物，符合类的定义特征　　

(1)类的定义：

class 类名{
    // 属性，变量

    // 行为，方法
}

类中需要注意的内容：

　成员变量，成员方法，静态变量，静态方法，局部变量，构造方法

成员变量和静态变量的区别，一个加static一个不加 如static String name

成员方法和静态方法的区别：一个有static一个没有，静态方法是通过类名调用，而成员方法是通过对象调用

局部变量：定义在方法或者是方法的参数列表上的变量

(2) 如何创建对象：

　　类名  对象名 = new 类名()

(3) 给对象赋值

　　对象名.属性 = 要赋的值

案例

创建一个Teacher 类,包含属性: 姓名,性别,年龄; 定义一个讲课的行为,和自我介绍的方法(用于打印所有的属性值),创建三个老师对象创建到数组中
创建教师类

public class Teacher {
　　 // 成员变量---属性
    String name;
    char gender;
    int age;
    double salary;
　　 // 成员方法：无static修饰的方法
    public void teaching() {
        System.out.println("上课");
    }
    public void chuiNiu() {
        System.out.println("吹牛");
    }
    public void show() {
        System.out.println("我的姓名是" + name + ",性别是" + gender + ",今年" + age);
    }
}    

测试类

public class TeacherDemo1 {
    public static void main(String[] args) {
        // 创建对象
        Teacher t1 = new Teacher();
        t1.name = "老王";
        t1.gender = '男';
        t1.age = 25;
        t1.salary = 4000;
        t1.teaching();
        t1.chuiNiu();
        t1.show();

        Teacher t2 = new Teacher();
        t1.name = "小红";
        t1.gender = '女'; //false表示女性
        t1.age = 28;
        t1.salary = 5000;
        t1.teaching();
        t1.chuiNiu();
        t1.show();

    }

1.4 内存分析

栈（stack）：方法的执行，局部变量的存放，其没有初始值（有指向存放初始值地方（堆）的地址）

堆：new出来的事物，有初始值，基本数据类型初始值就是默认值，引用数据类型初始值为null

方法区：

class区：所有字节码文件（.calss），类加载的时候会把相关字节码文件加载到class区中，同时把用static修饰的事物存入到静态区

static区：用static修饰的东西

案例（注释中为运行结果）

public class TeacherDemo {
    public static void main(String[] args) {
        Teacher t = new Teacher(); // 上面中的teacher类
        System.out.println(t); // com._51doit.javase.day7.Teacher@2ff4acd0（此叫全类名：包名+类名）
        System.out.println(t.name); // null
        System.out.println(t.age);  // 0
        System.out.println(t.salary); //0.0
    }
}

运行的结果可通过内存分析来理解，如下

大致流程（这里自己也疑惑，就把视频中老师讲的话记录下来了，感觉老师没把这块讲清楚，等以后看jvm原理再来修改）：

程序最开始不是从main方法开始执行，执行main方法前会有个加载的过程，得把类先加载到内存中才能执行。先执行main方法，而main方法的所在的类为TeacherDemo1，所以TeacherDemo1就得编译成.class文件。然后TeacherDemo1在编译的过程中发现用到了Teacher类，而要使用这个类，也得进行编译，并加载到内存当中，否则要用的话就找不到相应的类。其加载至class区域，即变成TeacherDemo1.class  和Teacher.class。紧接着会加载这两个字节码文件，加载的时候若发现有用static修饰的变量和方法就要将其放到static区域，如TeacherDemo1中的静态方法main就被存放到方法区中的static区，并给其一个地址假设为0x001（若是成员方法就存放在class区，本例中Teacher类中的成员变量都放到了class区）

当jvm执行时，其就会去找main方法（jvm只认识main方法），通过地址值找到static区域的main方法，然后就会去栈内存执行这个main方法。

首先Teacher t为局部变量，所以就被存储到栈的main方法中，而new Teacher（）被存放到堆中，同时在堆中开辟了一个内存空间，用来存放从class区获取到的事务（此处时name，gender，age，salary）。由于放到堆里的事务都是有初始值的，所以就要进行赋值（按规则赋值，如int类型赋值0等），此时会赋予这个空间一个地址号，main方法中也会有此地址号（本例为7852e922），前者就可以通过地址号找到后者。Main方法执行完后就从栈中弹出去，因此栈中就无指向堆中的指针，堆中的new Teacher（）就通过垃圾回收机制（GC）被回收掉。而方法区一般时jvm停掉后也没有了，只不过其存放的时间相比堆中会长点（方法存储区为内存永久带，不容易被回收）

以后整理可能有用的材料

假如在TeacherDemo类中再加入以下代码，运行的结果会是怎么样

        t.name = "张三";
        t.age = 13;
        Teacher t1 = new Teacher();
        t1.name = "李四";
        t = t1;
        System.out.println(t.name); // 李四
        System.out.println(t1.name); // 李四
        t.age = 80;
        System.out.println(t1.age);  //  80

分析如下图

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

成员变量：定义在类中方法外的变量，没有static修饰；

局部变量：定义在方法中或者是方法的参数列表上的变量

区别：

（1）在类中的位置不同

成员变量：方法外，类内

局部变量：方法内或者方法的参数列表中

（2）在内存中的位置不同

成员变量：堆内存

局部变量：栈内存

（3）生命周期不同

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

局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

（4）初始化值不同

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

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

1.6 匿名对象

　匿名对象就是没有名字的对象，是对象的一种简化表现形式

匿名对象的两种使用情况：

（1）对象的调用方法仅仅一次的时候

（2）作为实际参数传递

package com._51doit.javase.day7;

public class NoNameObjectDemo {
    public static void main(String[] args) {
        Teacher t = new Teacher();
        // 调用属性时，一般会用命名后的对象.属性
        System.out.println(t.name);
        System.out.println(t.age);
        // 下面就是匿名对象，其无名字,结果等价于上面代码
        // 注意：下面两行代码相当于在堆中开辟了两个空间
        // 匿名对象一般不用在调用属性，因为属性没有赋值，调用的也是默认值，没什么意义，所以匿名对象一般用在调用方法
        System.out.println(new Teacher().name);
        System.out.println(new Teacher().age);
    }
}

为什么说对象的调用方法仅仅一次？

原因：若调用多次（如下），会创建多个对象，堆中就要开辟多个空间，但若不使用匿名对象，同样调用多次，只在堆中开辟一个空间，所以使用匿名对象这种情况会浪费空间

new Teacher().show()
new Teacher().show()
t.show()
t.show()

匿名对象作为实际参数传递

首先在

NoNameObjectDemo类中创建一个test方法，如下：

// 注意此处test方法要接受的参数类型为Teacher类型的参数
public static void test(Teacher t) {
        t.show();
    }

在main()方法中调用test（）方法，代码如下

test(t);
test(new Teacher());// 此即为匿名对象作为参数传递

1.7 给类重命名的方法

第一种方式，在类文件上右键-->refactor-->rename

第二种方式，直接在雷伤改名（代码中），改完之后将光标放在类明上，根据自动提示，选择第一个

1.8  形参和实参

形参：定义方法时，方法参数列表上的变量
实参：调用方法时，传进去的具体值

注意：（1）基本数据类型作为参数，形参的改变不影响实参的值，如案例1
　　　（2）引用数据类型作为参数时，形参的改变，影响实参的值（String和包装类除外），如案例2
包装类有8种（图中右边）

package com._51doit.javase.day7;

public class ParamDemo {
    public static void main(String[] args) {
        sum(12,14); // 12,14为实参
    }
    public static void sum(int a,int b) { // int a和b为形参
        System.out.println(a+b);
    }
}

案例1

下面代码打印的a值为什么？

package com._51doit.javase.day7;

public class ParamDemo {
    public static void main(String[] args) {
        int a = 10;
        change(a);
        System.out.println(a);
    }
    public static void change(int a) {
        a = 100;
    }
}
运行结果： a=10

解释：

首先执行main()方法（方法的执行时在栈中），所以在栈中就存有一个main方法（入栈），main()方法中有一个局部变量a，并将a存放到main方法中，紧接着是change（）方法的执行，所以又会有一个change()方法入栈

change()方法执行完后就出栈，此处给change方法传了参数a=10，然后方法里面将a改成了100，但是修改后的a值并没有返回给main方法，所以a打印的值还是为10

案例2

下面代码打印的值为什么？

package com._51doit.javase.day7;

public class ParamDemo {
    public static void main(String[] args) {
        int[] arr = new int[]{10,20};此处换成新建一个对象并传递给相应方法时也是一样的效果
        change(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
    }
    public static void change(int[] arr) {
        arr[0] = 100;
        arr[1] = 200;
    }
}
运行结果为：100,200

 1.9 封装

（1）封装的概述：

　　指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

（2）优点

　　隐藏实现细节；提高代码的复用性；提高安全性

（3）封装原则：

　　将不需要对外提供的内容都隐藏起来

　　把属性隐藏，提供公共方法对其访问

实现封装的步骤

成员变量私有化：用private修饰成员变量

　　权限修饰符：

　　　　public：修饰类，方法，变量；可在本项目中访问，跨包需要导包

　　　（default）：修饰类，方法，变量，什么都不加，只能在本包中使用

　　　　private：修饰方法，变量；被private修饰的方法和变量只能在本类中访问

提供get和set

　　get方法：获取属性值

　　　　　　public 返回属性的类型 getXxx(){return 属性}

　　set方法：修改属性值

　　　　　　public void setXxxx(属性类型  用来接收属性值的参数){属性变量名=用来接收属性值的参数}

注意点

（1）get方法中需要有返回值，所以public后需接返回属性的类型，但set方法不需要返回值，所以直接void就行（见案例3）

　　   （2）this关键字：

　　　　　用来区分同名的成员变量和局部变量，this指代成员变量，this看做是一个本类的对象，this所在的方法正在被哪个对象调用，this就指代哪个对象

public void setName(String name){
    // 此处不加this的话就不能区分哪个是参数列表中的name哪个是成员变量name
    this.name = name // 若去掉this就会报错
}

具体见案例2

案例1

创建一个BeautifulGirl类，其包含属性name，weight，legLenth，并创建一个BeautifulGirlDemo类，在此类中对BeautifulGirl中的属性进行赋值

package com._51doit.javase.day7.fz;

public class BeautifulGirl {
        String name;
        double weight;
        double legLenth;
}

创建一个BeautifulGirlDemo类

package com._51doit.javase.day7.fz;

public class BeautifulGirlDemo {
    public static void main(String[] args) {
        BeautifulGirl b1 = new BeautifulGirl();
        b1.name = "小红";
        b1.legLenth = 150;
        b1.weight = 80;
        System.out.println(b1.weight);
        System.out.println(b1.legLenth);
    }
}

这种形式可以实现给类或者对象的属性赋值，但是不安全，使用者（此处是BeautifulGirl）可以随便修改类或者对象中的属性，很不安全，为了解决这个问题就出现了封装，如下

防止类中的属性被随意访问和修改，就要将变量私有化（加权限），代码如下

package com._51doit.javase.day7.fz;

public class BeautifulGirl {
        private String name;
        private double weight;
        private double legLenth;
}

改完之后，eclipse上就会显示这几个变量都未被使用，如下图

同时BeautifulGirlDemo类中的代码也出现了问题（The field BeautifulGirl.legLenth is not visible），如下

说明加上private的修饰后，BeautifulGirlDemo类就无法查看并修改BeautifulGirl类中的属性（变量）了，但有些时候又要给特定事务提供获取或修改该私有属性的方法，这个时候就用到了get方法和set方法，如下

案例2  使用封装的特性去实现案例1（这里为例方便，就只写出了一个name属性）

创建BeautifulGirl类

package com._51doit.javase.day7.fz;

public class BeautifulGirl {
　　　　 // 定义的私有属性
        private String name;
　　　　 // 定义返回name属性的get方法
        public String getName() {
            return name;
        }
　　    // 定义修改name属性的set方法
        public void setName(String name) {
            this.name = name;
        }
}

创建BeautifulGirlDemo类

package com._51doit.javase.day7.fz;

public class BeautifulGirlDemo {
    public static void main(String[] args) {
        BeautifulGirl b1 = new BeautifulGirl();
        b1.setName("小红");
        System.out.println(b1.getName());
    }
}
// 运行的结果为小红，说明设置姓名以及访问这个姓名的属性成功

为什么说这种设置，访问类或对象属性的方法更安全呢？因为这里的设置或访问属性都是通过调用方法的形式进行的，这种情况下可以在方法中设置前提条件（案例3是在setName和getName方法中加前提条件），设置这个私有属性谁可以访问，谁可以修改等

练习

使用封装的特性创建一个Dog类，类中包括的属性分别为为name，furColor, gender, age, type，此外要提供get和set方法。在DogTest类中创建2个对象，使用set方法赋值，使用get方法获取值

创建Dog类

package com._51doit.javase.day7.fz;

public class Dog {
    private String name;
    private String furColor;
    private char gender;
    private int age;
    private String type;
    // name属性的设置和查看
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    // furColor属性的设置和查看
    public String getFurColor() {
        return furColor;
    }
    public void setFurColor(String furColor) {
        this.furColor = furColor;
    }
    // gender属性的设置和查看
    public char getGender() {
        return gender;
    }
    public void setGender(char gender) {
        this.gender = gender;
    }
    // age属性的设置和查看
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    // type属性的设置和查看
    public String getType() {
            return type;
    }
    public void setType(String type) {
            this.type = type;
    }
}    

创建DogTest类

package com._51doit.javase.day7.fz;

public class DogTest {
    public static void main(String[] args) {
    Dog d1 = new Dog(); // 创建第一个对象d1
    d1.setName("旺财");
    d1.setFurColor("黑色");
    d1.setGender('公');
    d1.setAge(3);
    d1.setType("土狗");

    Dog d2 = new Dog(); // 创建第二个对象d2
    d2.setName("富贵");
    d2.setFurColor("黄色");
    d2.setGender('母');
    d2.setAge(2);
    d2.setType("中华田园犬");

    System.out.println(d1.getName()+","+d1.getFurColor()+","+d1.getGender()+","+d1.getAge()+","+d1.getType()); // 将属性获取并打印出来
    System.out.println(d2.getName()+","+d2.getFurColor()+","+d2.getGender()+","+d2.getAge()+","+d2.getType());
    }
}

1.10  构造方法

构造方法，也叫构造器（constructor），是类中比较特殊的一种方法

（1）格式

修饰符  类名（参数列表）{方法体;}

注意事项：

　　1. 方法和类名相同

　　2. 没有返回值，连void都没有

　　3. 构造方法是可以重载的

（2）构造方法何时被调用？

　　使用new 关键字创建对象的时候，就是在调用构造方法

　　如果要调用其他的构造方法，只需要在new后面的括号中，传入相应的参数即可

注意：如果我们不在类中创建构造方法，那么系统会为我们自动生成无参数的构造方法，但若我们在类中写了构造方法，那么系统则不再为我们生成

案例1  上面dog类的练习中，利用构造方法给变量赋值（传参）

直接在Dog类中添加一下代码，如下

 1 public class Dog {
 2     public Dog() {};
 3     public Dog(String name,int age,String furColor,String type,char gender) {
 4         this.name = name;
 5         this.furColor = furColor;
 6         this.gender = gender;
 7         this.age = age;
 8         this.type = type;
 9     };
10 //下面的代码同上诉Dog类

这时就不需要set来给变量赋值，直接在新创建的对象中传实参就行，如下

Dog d3 = new Dog("小强",12,"哈士奇","紫色",'母');
System.out.println(d3.getName()+","+d3.getFurColor()+","+d3.getGender()+","+d3.getAge()+","+d3.getType());

由低2和第3行的代码可知，构造方法是重载的，新建的对象会根据参数类型找相应的构造方法

注意：若将第二行代码去掉，则原先创建的无参数的对象就找不到对应的构造方法就会报错（自己创建了构造方法，就不会自动生成默认的无参数的构造方法了）

1.11 六大组件

成员变量
静态变量
局部变量
成员方法
静态方法
构造方法

1.12 给对象赋值的方式（前面内容也涉及，这里总结在一起）

第一种

对象名.属性名= 要赋的值

Teacher t = new Teacher();
t.name = “zhang san”;

第二种

使用set 方法:

t.setName(“李四”);

第三种

使用构造方法

Teacher t = new Teacher(“赵柳”,19);
class Teacher{
    public Teacher(String name,int age){
        this.name = name;
        this.age = age;
    }
}    

1.13 作业

1. 定义一个类Demo,其中定义一个求两个数据和的方法，定义一个测试类Test，进行测试。

public class AddDemo {
    double a;
    double b;
    public AddDemo(double a, double b) {
        this.a = a;
        this.b = b;
    }
    public double getSum() {
        return a+b;
    }
}

测试类

import java.util.Scanner;

public class AddDemoTest {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个数");
        double a = sc.nextDouble();
        System.out.println("请输入第一个数");
        double b = sc.nextDouble();
        AddDemo ad1 = new AddDemo(a, b);
        System.out.println("两数的和为：" + ad1.getSum());
    }
}

随意输入两个数，即可得到加和的值

2 定义一个长方形类,定义求周长和面积的方法，然后定义一个测试了Test2，进行测试。

public class Circle {
    private double r;
    private double pi;
    // r的获取和设置
    public double getR() {
        return r;
    }
    public void setR(double r) {
        this.r = r;
    }
    // pi的获取和设置
    public double getPi() {
        return pi;
    }
    public void setPi(double pi) {
        this.pi = pi;
    }
    // 求圆面积
    public double cirArea() {
        return pi*r*r;
    }
    // 求圆的周长
    public double cirGirth() {
        return 2*pi*r;
    }
}

测试类

import java.util.Scanner;

public class CircleTest {
    public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入r的值");
    double r = sc.nextDouble();
    System.out.println("请输入pi的值");
    double pi = sc.nextDouble();
    Circle c1 = new Circle();
    c1.setR(r) ;
    c1.setPi(pi);
    System.out.println("圆的面积为："+ c1.cirArea());
    System.out.println("圆的周长为："+ c1.cirGirth());
    }
}

3. 定义一个员工类,自己分析出几个成员，然后给出成员变量，构造方法，getXxx()/setXxx()方法，以及一个显示所有成员信息的方法。并测试。

4. 定义一个类MyMath,提供基本的加减乘除（add，sub，mul，div）功能，然后进行测试。