java面向对象——类和对象

一、面向对象和面向过程

面向对象：将所有的物品都当做是一个对象，将每个对象单独处理一些事情，也可以将多个对象组合在一起处理某些事情，如果业务中用到多次相同功能，这时可以重用该功能，相当于一个人同时可以做多件事情。
面向过程：代码从上往下执行，如果同一个功能，需要copy代码，它是一次性执行完毕，相当于一个人同时只能做同一件事情 。
面向对象是基于万物皆对象这个哲学观点

举例说明：

案例一：我想要吃大盘鸡

面向过程                            面向对象

1.自己去买菜                     1.委托一个会砍价的人帮忙去买菜

2.自己择菜                      2.委托一个临时工帮忙择菜

3.自己做菜                      3.委托一个厨师帮忙做菜

4.自己开始吃                     4.自己开始吃

案例二：小明是一个电脑小白，想要配一台电脑，买完零件后需要运到家里，组装完成后打开电脑玩游戏

面向过程                            面向对象

1.小明补充电脑知识      1.委托一个懂电脑的朋友(老王)去帮忙买零件

2.小明去买零件                2.委托一个能跑腿的人去买零件

3.小明把零件带回家里 2.委托一个快递小哥帮小明送到家里

4.小明组装电脑                3.委托一个会组装电脑的人帮小明组装电脑

5.小明开机玩电脑           4.小明自己打开电脑，开始玩游戏

区别总结
a.都是看待问题的一种思维方式，都能解决问题
b.面向过程着眼于所有的事情亲力亲为
c.面向对象着眼于找到一个具有特殊功能的对象，委托这个对象帮忙去做某件事情
注意：面向对象是一种思想，并不是一门编程语言。

二、类和对象

类：一个具有特殊功能的实体的集合【群体】，类是Java语言的最基本单位。
对象：在一个类中，一个具有特殊功能的实体，能够帮忙解决特定的问题，对象也被称为实例。

2.1类和对象的关系

a.类是对象的抽象，一个类可以new出多个对象，对象是类的具体体现
b.Java中描述事物通过类的形式体现,类是具体事物的抽象,对象即是该类事物实实在在的个体。

2.2 类的声明

语法：访问权限修饰符 class 类名 {
//类体
}
说明：a.访问权限修饰符：只能是public(可以被省略，省略后为default)
b.类名只要是一个合法的标识符即可，但是要求：首字母必须大写，遵循驼峰命名法
c.尽量使用单个或多个有意义的单词连接而成
public class Car {}
注意：a.一个Java文件中可以写多个类，如果写多个类，则编译后会生成多个.class文件
b.一个Java文件中最多只能有一个被public修饰的类，这个类的类名必须和Java源文件名保持一致
c.一个Java文件中如果只有一个类，并且这个类不用public修饰的话，类名和文件名可以不一样，但习惯上，我们都会写一样

2.3 类中成员变量的定义

成员变量：
a.成员变量其实就是全局变量，也叫实例变量
b.成员变量也被称为属性
c.分为静态变量和非静态变量
d.在静态方法中只能访问静态成员变量，在非静态方法中可以访问非静态成员变量和静态成员变量
成员变量【全局变量】和局部变量的区别：
a.定义的位置不同
成员变量：定义于类中，作用于整个类
局部变量：定义于方法或者语句中，作用于该方法或者该语句
b.内存中出现的时间和位置不同
成员变量：当对象被创建时，出现在堆内存当中。
局部变量：所属的区间被运算时，出现在栈内存当中
c.生命周期不同
成员变量：随着对象的出现而出现，随着对象的消失而消失。
局部变量：随着所属区间运算结束，它就被释放。
d.初始化值不同
成员变量：成员变量因为在堆内存当中，所以他有默认的初始值
局部变量：没有默认的初始值

2.4 类中方法的定义

a.分为静态方法和非静态方法
b.在同一个类中，在静态方法中只能调用静态方法，在非静态方法中可以调用非静态方法和静态方法

public class Demo {
    public int age =10; //定义一个非静态全局变量
    public static String name="Tom"; //定义一个静态成员变量
    public void show() { //非静态方法
        System.out.println("非静态方法show");
        //二：在同一个类中，非静态函数可以调用静态函数，也可以调用非静态函数
        display();
        showTwo();
    }
    public void showTwo() { //非静态方法
        System.out.println("非静态方法showTwo");
        //四、在同一个类中，在非静态函数中能访问静态全局变量和非静态全局变量
        System.out.println(name); //Tom
        System.out.println(age);
    }
    public static void display() { //静态方法
        System.out.println("静态方法display");

        System.out.println(name); //Tom
        //三、在同一个类中，在静态函数中只能访问静态全局变量
        // 错误: 无法从静态上下文中引用非静态变量 age
        //System.out.println(age);
    }
    //main函数式静态方法
    public static void main(String[] args) {
        display();
        /*
         * 一、静态方法中不能直接调用非静态方法
         * 会编译错误：无法从静态上下文中引用非静态 方法 display()
         */
        //show(); //Cannot make a static reference to the non-static method show() from the type Demo

        //定义一个局部变量，当局部变量与全局变量重名时，访问采用就近原则。
        //应该避免这种情况
        int age=20;
        System.out.println(age); //20

        new Demo().showTwo();
    }

}

三、对象的创建和内存分析

3.1 对象的创建

对象的创建过程也被称为对象的实例化过程
语法：类名 标识符 = new 类名();

/**
 * 实体类：表示具有某些特征或者某些行为的类
 * 描述多个对象所具有的共同特征和共同行为
 * 需求：人类，具有姓名，年龄，性别，国籍等的特征，可以吃东西，可以奔跑，，，
 */
class Person {
    //成员变量：特征或属性【名词】
    //非静态
    String name;//null 初始化为null
    int age;//0
    char sex;//\u0000
    //静态
    static String country;//null

    //成员方法：行为【动词】
    //静态方法
    public static void running() {
        System.out.println("Running~~~");
    }
    //非静态方法
    public void eat() {
        System.out.println("Eating~~~");
    }
}
//测试类：含有main函数的类称为测试类
//跨类调用成员方法和属性
public class Demo1{
    public static void main(String[] args) {
        //1.创建tom这个人的对象      语法:类名 变量名称  = new  类名();
        Person tom = new Person();
        //2.调用其他类中的非静态方法和访问其他类中非静态成员变量    语法：对象.
        System.out.println(tom.name+" "+tom.age); //null 0
        tom.eat(); //Eating~~~
        //虽然是跨类进行访问，Person类中成员变量仍然是一个变量，值可以随时发生改变
        tom.age=20;
        System.out.println(tom.age); //20
        //3.调用其他类中的静态方法和访问其他类中静态成员变量   语法：对象.   或者  类名.
        Person.country="中国";
        System.out.println(tom.country);//中国
        System.out.println(Person.country);//中国
        tom.running(); //Running~~~
        Person.running();//Running~~~
        //4.可以创建多个对象
        Person mary = new Person();
        Person alice = new Person();
    }
}

3.2 内存分析

当创建对象的时候，会在堆中分配一块内存空间给这个对象，非静态成员也随对象在堆中，虚拟机会对它们初始化；静态成员在静态块中，属于一个共享区域。在栈中的变量保存对象的引用。

说明：程序中定义的Person类型的变量实际上是一个引用，它被存放在栈内存中，他指向实际的Person对象，而真正的Person对象则存放于堆内存中

四、构造方法

4.1 构造方法的定义

构造方法也叫构造器，是指当实例化一个对象（创建一个对象）的时候，第一个被调用的方法
语法：访问权限修饰符 类名() { //方法体 }
普通方法：
访问权限修饰符 其他的修饰符 返回值类型 函数名（参数列表） { //方法体 }
说明：a.构造方法是在实例化对象的过程中自动调用的
b.系统会默认为我们提供一个无参的构造方法
c.构造方法没有返回值类型
d.当在类中创建了有参的构造方法，创建对象的时候，就调用的有参构造方法，必须传参数，系统对无参的构造方法屏蔽了，如果要创建不传参对象，就得显示声明无参构造方法。
e.构造方法也就是构造器，并不是一个真正的“方法” ，构造器不是静态方法。具体解释可以参考这篇博客：http://rednaxelafx.iteye.com/blog/652719

4.2 构造方法的调用

public class Demo2 {

    public static void main(String[] args) {
        //系统默认调用无参构造方法
        Animal animal = new Animal();

        Animal animal2 = new Animal("cat");
        animal2.show();
    }

}
//创建一个动物类
class Animal{
    String name;
    //无参构造方法   构造方法是在实例化对象的过程中自动调用，不需要手动调用的
    public Animal() {
        System.out.println("无参构造方法");
    }
    //当手动添加一个有参的构造方法之后，系统将不再提供无参的构造方法
    //如果要使用无参的构造方法，只能手动添加
    public Animal(String name) {
        this.name = name;
        System.out.println("有参构造方法"+name);
    }
    public void show() {
        System.out.println("有参构造方法的show方法"+name);
    }
}

运行结果：

无参构造方法
有参构造方法cat
有参构造方法的show方法cat

4.3 构造方法和普通方法的区别

a.构造方法是在创建对象的过程中自动调用的，普通方法只能手动进行调用
b.构造方法没有返回值类型【注意区别返回值void】，普通方法的返回值类型要么是确定的类型，要么为void
c.系统会默认为我们提供一个无参的构造方法,普通方法只能手动添加
d.构造方法的方法名称必须和对应的类名保持一致
e.构造方法在创建对象的过程中就会执行，而且每个对象只执行一次，对于普通方法而言，只有在需要使用的时候才被执行，并且一个对象可以调用多次

注意：
a.如果没有写有参的构造方法，系统会默认提供一个无参的构造方法
b.如果手动写了有参的构造方法，系统将不再提供无参的构造方法，如果需要使用，则要手动添加（一般情况下，要求将无参的构造方法都写上，哪怕方法里面什么都不写）