Java面向对象(上)

Posted 2021-01-21 hh2012

Java—面向对象（上）

1.面向对象的设计思想

　　面向对象有一个非常重要的设计思维：合适的方法应该出现在合适的类里面。

　　面向对象的基本思想是，从现实世界中客观存在的事物出发来构造软件系统，并在系统的构造中尽可能运用人类的自然思维方式。

　　面向对象更加强调运用人类在日常生活的逻辑思维中经常采用的思想方法与原则，如抽象、分类，继承、聚合、多态等。

　　人在思考的时候，首先眼睛里看到的是一个一个的对象。

2.对象和类的概念　　

　　1.对象

　　　　对象用计算机语言对应问题域中事物的描述，对象通过“属性（attribute）”和“方法（method）”来分别对应事物所具有的静态属性和动态属性

　　2.类

　　　　类是用于描述同一类型的对象的一个抽象的概念，类中定义了这一类对象所应该具有的静态和动态属性

　　3.类和对象的关系

　　　　类可以堪称一类对象的模版，对象可以堪称该类的一个具体实例。使用 new 关键字或反射技术创建的某个类的实例。同一个类的所有对象，都具有相似的数据（比如人的年龄、性别）和行为（比如人的吃饭、睡觉），但是每个对象都保存着自己独特的状态，对象状态会随着程序的运行而发生改变，需要注意状态的变化必须通过调用方法来改变，这就是封装的基本原则。

　　　　 

　　　　所有的面向对象编程语言都具有三大特性：封装、继承和多态。

3.对象

　　1.对象概述　

• • 对象是java程序的核心，在java程序中“万事万物皆对象”

  • 对象可以堪称是静态属性（成员变量）和动态属性（方法）的封装体

  • 类是用来创建统一类型的对象的“模版”，在一个类中定义了该类对象所应具有的成员变量以及方法

　　2.成员变量

　　　　成员变量可以是java语言中任何一种数据类型，包括基本数据类型和引用数据类型。在定义成员变量时，可以对其进行初始化，也可以不初始化，java默认使用默认的值（0、null等针对不同数据类型有不同赋值，但是都是最基础的0或空）对其进行初始化（成员变量可以不初始化，局部变量必需初始化）。成员变量的作用范围为整个类体。

　　3.对象的引用

　　　　Java中必需使用new关键字创建对象；使用对象（引用）.成员变量来引用对象的成员变量；使用对象（引用）.方法（参数列表）来调用对象的方法；同一类的的每个对象有不同的成员变量存储空间；同一类的每个对象共享该类的方法

　　　　java中的对象是通过引用对其进行操作的。例如：　　　

　　　　//声明了一个string类型的引用变量，但并没有使他指向一个对象
　　　　String s;
　　　　//使用new语句创建了一个string类型的对象并使用s指向它，以后可以通过s完成对其的操作
　　　　s = new String("helloWorld");　　　

　　　　注意：类是静态的概念，存放在代码区，对象是new出来的，位于堆内存，类的每个成员变量在不同的对象中都由不同的值（除静态变量）而方法只有一份，执行的时候才占用内存。

4.java类

　　类的定义主要有两方面组成：成员变量和方法

　　声明类的格式为：

　　　　修饰符 class(关键字) 类名{}   

　　　　[modifiers] type <attr_name> [=defiultValue];

　　　　例如：public int id;          private int age = 20;

　　

//用class关键字定义一个类，例如：
class Test {
    //成员变量定义
    public int id;    //公有成员变量
    private int age = 20;    //私有成员变量
    //方法定义
    public int getAge() {
        return age;
    }
    
    public void setAge(int i) {
        age = i;
    }
    
    public int getId() {
        return id;
    }
}

　　声明方法的格式为：

[<modifiers>] <modifuers> <return_type> <name> ([argu_list]) {<statements>}

例如：public int getAge() {return age; }

5.构造方法（构造函数)

 　　构造函数的特点：(1)使用new+构造方法创建一个新的对象(2)构造函数是定义在java类中的一个用来初始化对象的函数(3)构造函数与类同名且没有返回值

　　例如：

//定义一个类
public class Test {
    //定义成员变量
    int id;
    int age;
    //构造方法
    Test(int n,int i) {
        id = n;
        age = i;
    }
}
//其中Test(int n, int i)就是Test类的构造方法

构造方法名与类名必需一致

构造方法不能有返回值，不能有void

　　创建对象时，使用构造函数初始化对象的成员变量　　

//定义一个测试类
public class Test1 {
    //主方法
    public static void main(String args[]) {
        //new了一个刚刚的Test对象并传入实参
        Test tom = new Test(1,25);
        Test jhon = new Test(2,27);
    }
}
//注意这个测试类的主方法创建了Test类的两个实例，即在堆内存中存在两个内存地址，一个存tom对象，一个存jhon对象
//创建这两个实例对象时，调用的就是Test类的Test(int n,int i)这个构造方法

　　当没有指定构造函数时，编译器为类自动添加如：

　　类名（）｛｝的构造函数，例如：

//定义一个测试类
public class Test1 {
    public int x;
    //主方法
    public static void main(String arg[]) {
        Test1 x1 = new Test1();
    }
}

//如上的代码中编译是不会出现报错的，它等价于：

//定义一个测试类
public class Test1 {
    public int x;
    //主方法
    Test1(){}    //这个就是java自动生成的构造方法
    public static void main(String arg[]) {
        Test1 x1 = new Test1();
    }
}

6.内存分析

 　　实例分析：　

//定义一个类
class Person{
    private int age;
    private String name;
//构造方法
    Person(int age,String name){
       this.age = age;
       this.name = name;
   }
    public int getAge(){
   　　return age;
   }　
    public int getName(){
   　　return name;
   }
    public void display() {
        System.out.println("姓名："+name + " 	年龄：" + age);
    }
} 
//其中	是制表符

 

//测试类
public class Test {
    //主方法
    public static void main(String args[]) {
        Test test = new Test();
        int date = 19;
        Person p1 = new Person(20,"Tom");
        Person p2 = new Person(24,"Jiexi");
        test.change1(date);
        test.change2(p1);
        System.out.println("date = "+date);
        p1.display();
        p2.display();
    }
    //定义方法
    public void change1(int i) {
        i = 1234;
    }
    public void change2(Person p) {
        p = new Person(22, "Tom");
    }
}

　　调试输出：

date = 19
姓名：Tom  年龄：20
姓名：Jiexi  年龄：24

 　　test.change1执行完毕后date的值没有变，栈内存空间中给i分配的空间消失

　　test.change2执行完毕后p1的值没有变，栈内存空间中分配给p的内存空间消失，但是p指向的堆内存空间中的值暂时未消失（会由java的垃圾回收机制自动回收）

　　程序执行到new一个p2对象出来的时候内存布局应该是这样的（左栈右堆）：