Java面向对象（1）

我们知道面向对象有三大特征：封装（encapsulation）,继承(inheritance),多态(polymorphism)。和面向过程不同的是，java来描述一个事物，是通过对象来表达的。

对象的创建

public class Car {String color;// 成员变量    int num; // 成员变量    // 成员函数    void run() {        System.out.println(color + "的车，轮胎数：" + num + "个，跑起来了");    }}

对象是怎么创建的呢？new一个。。。就像new数组一样。
变量都是有类型的，car属于什么类型，属于Car类型，这叫做类类型。
汽车对象生产出来之后，还没有起名字，为了方便实用，需要一个名字，就用小写c表示新车的名字。
那么c是什么类型？c是car类型，所以c也叫做类类型变量。

对象成员的调用

有了car对象，就可以调用成员的变量和方法。

public class CarDemo {    public static void main(String[] args) {        Car c = new Car();        //对象名.成员变量名将返回成员变量中存储的数值        int num=c.num;         System.out.println(num);        //对象名.成员变量名,也可以给成员变量赋值        c.num = 4;        c.color = "black";        //对象名.成员方法();        c.run();    }}

局部变量和成员变量

成员变量: 定义在类中变量
局部变量: 定义在方法中变量
成员变量与局部变量的区别：
一.应用范围
1.成员变量在整个类内都有效
2.局部变量只在其声明的方法内有效
二.生命周期
1.成员变量: 它属于对象，它随着对象的创建而创建，随着对象的消失而消失
2.局部变量: 使用完马上释放空间。
void show(int id){
for(int i=0;i<10;i++){
for(int j=0;j<10;j++){
System.out.println(id);
}
}
}
这时候 id,i,j者是在方法内声明的，全是局部变量
j当里层for循环执行它的生命周期开始，当里层for结束，j消失
i当外层for循环执行它的生命周期开始，当外层for结束，j消失
id在方法被调用时开始，方法结束时，id消失.
三.存储位置 成员变量属于对象，它存储在堆内，堆内的实体，当没有引用指向其时，才垃圾回收清理 局部变量存在栈内存中，当不在使用时，马上就会被释放。

内存分析

//汽车class Car {    //汽车应该具备的属性    int num;    //汽车具备的颜色    String color;    //汽车跑的行为    public void run(){        System.out.println(num+"轮子的汽车跑起来啦");    }}public class CarDemo{    public static void main(String[] args)    {   //创建实体，并且给该实体起一个名字        Car c = new Car();        c.color = "red";        c.num = 4;        c.run();//指挥车进行运行。调用格式：对象.对象成员    }}

匿名对象

一.匿名对象：没有名字的实体，也就是该实体没有对应的变量名引用。
2.2匿名对象的用途
1，当对象对方法进行一次调用的时候，可以使用匿名对象对代码进行简化。
为什么只对方法，而不调用属性呢？因为匿名对象调用属性没意义。
如果对象要多成员进行多次调用，必须给对象起个名字。不能在使用匿名对象。
2，匿名对象可以实际参数进行传递。
二：匿名对象的简单演示
1：new Car().run();
三：内存结构图
1：new Car().num=5;
2：new Car().clor=”blue”;
两个new 是两个不同的对象，在堆内存中有不同的空间，相互不相互干扰。
四：匿名对象的使用
1：当只使用一次时可以使用匿名对象。执行完毕到;后该对象就变成了垃圾。
new Car().run();
2:执行方法时，可以将匿名对象作为实际参数，传递进去。

封装

这是面向对象的第一个特征，如果不使用封装，那么很容易赋值错误，并且任何人都可以修改。造成信息的不安全。

那么怎么实现封装呢？
1：设置类的属性为private(关键字)，不能使用对象名.属性名的方式直接访问对象的属性。

package oop01;public class EmployeeDemo {    public static void main(String[] args) {        // 创建对象        Employee jack = new Employee();        //编译报错        jack.name = "jack";        jack.id = "123456";        jack.gender = "男";        // 编译报错        jack.gender = "不是男人";        jack.work();    }}class Employee {   //使用了private修饰了成员变量    private String name;    private String id;    private String gender;    public void work() {        System.out.println(id + ":" + name + ":" + gender + " 努力工作中！！！");    }}

问题：
1：为什么之前可以通过对象名.属性名的方式访问？
2：public 成员修饰符，公共的谁都可以访问。
3：private 成员修饰符，私有的，只有自己可以访问。
2：修改Employee类 性别的修饰符修改为private
1：编译不通过
2：private修饰的成员在自己所在的类中可以使用，在类外边不可以使用。
3：Employee类的gender的修饰符修改为private后，无法再类外调用，那么如何给gender设置值？
1：对外提供公开的用于设置对象属性的public方法
1：设置set
2：获取get
2：在set方法中加入逻辑判断，过滤掉非法数据。
3：将所有的成员变量封装加上private，提供get、set方法

class Employee {    private String name;    private String id;    private String gender;    // 提供公有的get set方法    public String getName() {        return name;    }    public void setName(String n) {        name = n;    }    public String getId() {        return id;    }    public void setId(String i) {        id = i;    }    public String getGender() {        return gender;    }    public void setGender(String gen) {        if ("男".equals(gen) || "女".equals(gen)) {            gender = gen;        } else {            System.out.println("请输入\"男\"或者\"女\"");        }    }    public void work() {        System.out.println(id + ":" + name + ":" + gender + " 努力工作中！！！");    }}

那么封装的好处是啥？
1.隐藏了类的具体实现
2.操作简单。
3.提高了对象数据的安全性。

构造方法（构造器）

作用呢就是给对象进行初始化。

构造函数与普通的函数的区别

1.一般函数是用于定义对象应该具备的功能。而构造函数定义的是，对象在调用功能之前，在建立时，应该具备的一些内容。也就是对象的初始化内容。
2.构造函数是在对象建立时由jvm调用, 给对象初始化。一般函数是对象建立后，当对象调用该功能时才会执行。
3.普通函数可以使用对象多次调用，构造函数就在创建对象时调用。
4.构造函数的函数名要与类名一样，而普通的函数只要符合标识符的命名规则即可。
5.构造函数没有返回值类型。

构造函数注意的细节

1. 当类中没有定义构造函数时，系统会指定给该类加上一个空参数的构造函数。这个是类中默认的构造函数。当类中如果自定义了构造函数，这时默认的构造函数就没有了。
   备注：可以通过javap命令验证。
   2.在一个类中可以定义多个构造函数，以进行不同的初始化。多个构造函数存在于类中，是以重载的形式体现的。因为构造函数的名称都相同。

This关键字

class Person {    String name;    int age;    //无参数构造函数    Person() {        System.out.println("这是无参的构造函数");    }    //有参数构造函数    Person(int a) {        age = a;        System.out.println("有参构造1");    }    //有参数构造函数    Person(String n) {        name = n;        System.out.println("有参构造2");    }    //有参数构造函数    Person(int a, String n) {        age = a;        name = n;        System.out.println("有参构造");    }    //普通函数    void speak() {        System.out.println("hah");    }}

假设定义40个成员变量，第一个有参构造初始化20个变量，第二个有参构造需要初始化40个变量。
1：第二个有参构造想要使用第一个有参构造。
2：成员函数相互之间可以调用。构造函数可以吗？
3：编译失败，那么构造函数之间应该存在相互调用的模式。this就可以完成这个工作。

class Person {    String name;    int age;    Person() {    }    Person(String n){        name=n;    }    Person(String n, int a) {        //编译报错        Person(n);        age = a;    }}

3：总结：实际工作中，存在着构造函数之间的相互调用，但是构造函数不是普通的成员函数，不能通过函数名自己接调用
所以sun公司提供this关键字。
2：this是什么
1：在构造函数中打印this
2：创建对象，打印对象名p
3：this和p是一样的都是内存地址值。
4：this代表所在函数所属对象的引用。
5：this只能在非静态中（没有static修饰的）函数使用
6：构造函数间相互调用必须放在构造函数的第一个语句中，否则编译错误
7：可以解决构造函数中对象属性和函数形参的同名问题。

下次主要讲解继承部分~