舔砖加瓦（java）之java面向对象

添砖加瓦（java）

java面向对象

前言：

大家好我是kdy丶

一丶面向对象与面向过程：

面向对象学习的主线归纳总结起来主要有三条：

1.Java类及类的成员：属性、方法、构造器；代码块、内部类
2.面向对象的大特征：封装性、继承性、多态性、(抽象性)
3.其它关键字：this、super、static、final、abstract、interface等

但说到面向对象我们就不得不首先说说他和面向过程之间的区别

1丶面向对象与面向过程的区别：

1丶面向对象与面向过程的区别：

首先我在这里问大家一个问题：怎么打开电脑，并下载qq？
看似一个简单的问题，其实里面大有学问！

1)面向过程的解决办法：
1丶打开总电源的开关
2丶走到电脑前面，插上电源
3丶打开电脑的电源
4丶下载qq

2)面向对象的解决办法：
1丶人：插电源的方法，打开开关的方法，启动电脑电源的方法 ，操作电脑的方法。
2丶电脑：启动电脑的方法，下载qq的方法。
3丶人通过插电源的方法，打开开关的方法，启动电脑电源的方法。让电脑启动，之后再通过操作电脑的方法让电脑下载qq。

通过这个简单的例子我们可以看出，面向过程主要进行的是步骤，不再乎是谁做的。而面向对象主要看的是每个对象和类的功能，非常在乎是谁做的而是有哪些功能！

我们在看看一下网上一位大佬举的非常权威的例子：

1)可以拿生活中的实例来理解面向过程与面向对象，例如五子棋，面向过程的设计思路就是首先分析问题的步骤：1、开始游戏，2、黑子先走，3、绘制画面，4、判断输赢，5、轮到白子，6、绘制画面，7、判断输赢，8、返回步骤2，9、输出最后结果。把上面每个步骤用不同的方法来实现。

2）如果是面向对象的设计思想来解决问题。面向对象的设计则是从另外的思路来解决问题。整个五子棋可以分为1、黑白双方，这两方的行为是一模一样的，2、棋盘系统，负责绘制画面，3、规则系统，负责判定诸如犯规、输赢等。第一类对象（玩家对象）负责接受用户输入，并告知第二类对象（棋盘对象）棋子布局的变化，棋盘对象接收到了棋子的变化就要负责在屏幕上面显示出这种变化，同时利用第三类对象（规则系统）来对棋局进行判定。

可以明显地看出，面向对象是以功能来划分问题，而不是步骤。同样是绘制棋局，这样的行为在面向过程的设计中分散在了多个步骤中，很可能出现不同的绘制版本，因为通常设计人员会考虑到实际情况进行各种各样的简化。而面向对象的设计中，绘图只可能在棋盘对象中出现，从而保证了绘图的统一。

所以总结起来：

1.面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。
2.面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

2丶面向对象与面向过程的优缺点：

我们还是用一个例子来说明问题，包饺子：
如果是面向对象，我们可以想把皮和馅分开，我想要什么样的皮和什么样的馅都可以。
如果是面向过程，那馅和皮就分不开，因为我只在意这个过程，我是否把饺子包完。什么馅的饺子和什么形状的饺子已经完成。

可是却在半路相到一个问题，我不想吃酸菜馅饺子，我想吃肉馅的！

这个时候面向对象的优点就充分体现出来了，我可以随时包什么馅的都可以。面向过程则还要把皮和馅分离才行。

也就是所面向对象耦合性比面向过程相对来说要低，面向过程性能方面
上要更加的好。

面向过程:

优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、 Linux/Unix等一般采用面向过程开发，性能是最重要的因素。
缺点：没有面向对象易维护、易复用、易扩展

面向对象:

优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统 更加灵活、更加易于维护
缺点：性能比面向过程低

二丶类与对象：

我们在上面已经充分的体会到了什么是面向对象，设计面向对象的程序时候我们应该很清楚地意识到：

面向对象程序设计的重点是类的设计
设计类，就是设计类的成员。

1丶类和对象的思想概述：

类：对一类事物的描述，是抽象的、概念上的定义
对象：是实际存在的该类事物的每个个体，因而也称为实例(instance)

二者的关系：
对象，是由类new出来的，派生出来的

（在这里我们常常会听见这样的一个名词：对象的实例化，实例化对象，将对象实例化等等，其实这一系列相同类型的说辞就是将类具体化，也就new出一个对象）

我们可以理解为：类 = 抽象概念的人；对象 = 具体的某个人

2丶类和对象的语法格式：

class 类名称{
属性名称;
返回值类型 方法名称(){}
}
对象的定义：
一个类要想真正的进行操作，则必须依靠对象，对象的定义格式如下：
类名称 对象名称 = new 类名称() ;

如果要想访问类中的属性或方法（方法的定义），则可以依靠以下的语法形式：
访问类中的属性：对象.属性 ;
调用类中的方法：对象.方法();

3丶类的成员

1）简单介绍类的属性和行为：

常见的类的成员有：

1丶属性：对应类中的成员变量
2丶行为：对应类中的成员方法

属性和行为就好比：
我是一个人（类），我的姓名和身体的特征等等都属于属性，我能敲代码，玩手机，做饭，就是人这个类的行为。
我们用代码实现这个程序：

public class demo01 {
   
    public static void main(String[] args) {
   
        //对象实例化
        person p=new person();
        //调用属性
        System.out.println(p.name = "唐三");
        System.out.println(p.age = 18);
        System.out.println(p.sex = "男");
        //调用方法
        p.eat();
        p.play();
        p.see("电影");
    }
}
class person{
   
    //属性
    String name;//姓名
    int age;//年龄
    String sex;//性别

    //方法（行为）
    public void eat(){
   

        System.out.println("吃饭");
    }
   //方法（行为）
    public void play(){
   
        System.out.println("打篮球");
    }
    //方法（行为）
    public void see(String s){
   
        System.out.println("看"+s);
    }
}

运行结果：

面向对象的程序设计主要是设计类，而设计类主要是设计类中的成员。

在这里我们就不得具体不说一说属性和方法了。

2）类的结构之属性：

对比：属性(成员变量) vs 局部变量

1丶相同点：

1 定义变量的格式：数据类型 变量名 = 变量值
2 先声明，后使用
3 变量都其对应的作用域

2丶不同点：

1. 在类中声明的位置的不同

属性：直接定义在类的一对{}内
局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部 的变量

2. 关于权限修饰符的不同

1丶属性：可以在声明属性时，指明其权限，使用权限修饰符。
常用的权限修饰符：private、public、缺省、protected —>封装性
2丶局部变量：不可以使用权限修饰符。

3. 默认初始化值的情况：

属性：类的属性，根据其类型，都默认初始化值。
整型（byte、short、int、long：0）
浮点型（float、double：0.0）
字符型（char：0 （或’\u0000’））
布尔型（boolean：false）
引用数据类型（类、数组、接口：null）
局部变量：没默认初始化值。
意味着，我们在调用局部变量之前，一定要显式赋值。
特别地：形参在调用时，我们赋值即可。

4. 在内存中加载的位置：

属性：加载到堆空间中 （非static）
局部变量：加载到栈空间

3）类的结构之方法：

1丶方法的声明:

权限修饰符 返回值类型 方法名(形参列表){
方法体
}

2丶权限修饰符：

权限修饰符：默认方法的权限修饰符先都使用public
Java规定的4种权限修饰符：private、public、缺省、protected -->封装性再细说

3丶返回值类型： 返回值 vs 没返回值

如果方法返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用return关键字来返回指定类型的变量或常量：“return 数据”。

如果方法没返回值，则方法声明时，使用void来表示。通常，没返回值的方法中，就不需要使用return.但是，如果想使用的话，只能“return;”表示结束此方法的意思。

4丶 方法名和形参：

属于标识符，遵循标识符的规则和规范，“见名知意”

形参列表： 方法可以声明0个，1个，或多个形参。
格式：数据类型1 形参1,数据类型2 形参2,…

5丶 方法体

方法功能的体现

4)类的结构之构造器

1.构造器（或构造方法）：Constructor

构造器的作用：

1.创建对象
2.初始化对象的信息

构造器可以创建对象，为什么可以？我们可以思考，在前面创建那么多的对象怎么没见到构造器？
我们看一下:

kid k1=new kid();

我创建了一个类叫kid，我们在进行创建对象的时候new kid();这个
就是创建对象，但是我们new 后面那个kid()是什么？是一个类吗？
其实不是如果吧括号去掉，只写kid那么他确实是一个类，但是他加上了括号就是一个构造器！
所以我们创建对象的时候都是new +构造器来创建出来的对象。

初始化对象的信息我们可以这么理解：
就像我们人类一样先天就要吃饭，我们可以将吃饭的代码加入人类的构造器中，让他就有这个特性，而不是要单独创建一个方法去让对象调用。
2.使用说明：

1.如果没显式的定义类的构造器的话，则系统默认提供一个空参的构造器
2.定义构造器的格式：权限修饰符 类名(形参列表){}
3.一个类中定义的多个构造器，彼此构成重载
4.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
5.一个类中，至少会有一个构造器。
6.父类的构造器不可被子类继承

3丶构造器的格式：
修饰符 类名 (参数列表) {
初始化语句；
}
例子：

public class demo05 {
   
    public static void main(String[] args) {
   
           kid k1=new kid();
           kid k2=new kid("kdy",21);

    }

}
//类
class kid{
   
    String name;
    int age;
    //构造器
    public kid(){
   
        System.out.println("我是一个孩子");
    }
    //就有形参的构造器
    public  kid(String name,int age){
   
        System.out.println("我的名字是"+name);
        System.out.println("我是一个"+age+"岁的孩子");

    }
}

运行结果：

我们在这里已经理解了构造器的格式和使用。说到这里我们可能会想为什么我们kid k1=new kid();就会把输出的结果打印出来？其实这就是一个硬性规定。如果解释的话也能强行解释：

我们都知道，如果没显式的定义类的构造器的话，则系统默认提供一个空参的构造器。所以当我们平常不创建构造方法，默认系统给我们程序一个无参数构造器的的时候，创建对象是什么也输出不出来的 ；只有自己给构造器里面添加内容才会显示出来。

但构造器主要的作用并不是显不显示什么内容，他的主要作用是： 1.创建对象 2.初始化对象的信息。

4丶对象的内存解析：

我们看这一段代码：

public class demo01 {
   
    public static void main(String[] args) {
   
        person p1=new person();
        System.out.println(p1.name="小明");
        System.out.println(p1.age);
        person p2=new person();
        System.out.println(p2.sex);
        person p3=p1;
        p3.age = 10;
        System.out.println(p1.age);

    }
}

class person{
   
    //属性
    String name;//姓名
    int age;//年龄