零基础学习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)功能,然后进行测试。





 

posted @ 2019-08-07 11:30  一y样  阅读(274)  评论(0编辑  收藏  举报