前言:
 
如果你很想搞明白面向对象是什么，面向过程是什么，或者说二者之间的区别是什么，那么就花费一点时间来研读一下这篇博客，你一定会有很大的收获的！
 
一、面向对象与面向过程的区别
 
面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了；面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。
 
可以拿生活中的实例来理解面向过程与面向对象，例如五子棋，面向过程的设计思路就是首先分析问题的步骤：1、开始游戏，2、黑子先走，3、绘制画面，4、判断输赢，5、轮到白子，6、绘制画面，7、判断输赢，8、返回步骤2，9、输出最后结果。把上面每个步骤用不同的方法来实现。
 
如果是面向对象的设计思想来解决问题。面向对象的设计则是从另外的思路来解决问题。整个五子棋可以分为1、黑白双方，这两方的行为是一模一样的，2、棋盘系统，负责绘制画面，3、规则系统，负责判定诸如犯规、输赢等。第一类对象（玩家对象）负责接受用户输入，并告知第二类对象（棋盘对象）棋子布局的变化，棋盘对象接收到了棋子的变化就要负责在屏幕上面显示出这种变化，同时利用第三类对象（规则系统）来对棋局进行判定。
 
可以明显地看出，面向对象是以功能来划分问题，而不是步骤。同样是绘制棋局，这样的行为在面向过程的设计中分散在了多个步骤中，很可能出现不同的绘制版本，因为通常设计人员会考虑到实际情况进行各种各样的简化。而面向对象的设计中，绘图只可能在棋盘对象中出现，从而保证了绘图的统一。
 
上述的内容是从网上查到的，觉得这个例子非常的生动形象，我就写了下来，现在就应该理解了他俩的区别了吧，其实就是两句话，面向对象就是高度实物抽象化、面向过程就是自顶向下的编程！
 
二、面向对象的特点
 
 在了解其特点之前，咱们先谈谈对象，对象就是现实世界存在的任何事务都可以称之为对象，有着自己独特的个性
 

 属性用来描述具体某个对象的特征。比如小志身高180M，体重70KG，这里身高、体重都是属性。
 面向对象的思想就是把一切都看成对象，而对象一般都由属性+方法组成！
 
属性属于对象静态的一面，用来形容对象的一些特性，方法属于对象动态的一面，咱们举一个例子，小明会跑，会说话，跑、说话这些行为就是对象的方法！所以为动态的一面， 我们把属性和方法称为这个对象的成员！
 
类：具有同种属性的对象称为类，是个抽象的概念。比如“人”就是一类，期中有一些人名，比如小明、小红、小玲等等这些都是对象，类就相当于一个模具，他定义了它所包含的全体对象的公共特征和功能，对象就是类的一个实例化，小明就是人的一个实例化！我们在做程序的时候，经常要将一个变量实例化，就是这个原理！我们一般在做程序的时候一般都不用类名的，比如我们在叫小明的时候，不会喊“人，你干嘛呢！”而是说的是“小明，你在干嘛呢！”
 
面向对象有三大特性，分别是封装性、继承性和多态性，这里小编不给予太多的解释，因为在后边的博客会专门总结的！
 
三、面向过程与面向对象的优缺点
 
很多资料上全都是一群很难理解的理论知识，整的小编头都大了，后来发现了一个比较好的文章，写的真是太棒了，通俗易懂，想要不明白都难!
 
用面向过程的方法写出来的程序是一份蛋炒饭，而用面向对象写出来的程序是一份盖浇饭。所谓盖浇饭，北京叫盖饭，东北叫烩饭，广东叫碟头饭，就是在一碗白米饭上面浇上一份盖菜，你喜欢什么菜，你就浇上什么菜。我觉得这个比喻还是比较贴切的。
 
蛋炒饭制作的细节，我不太清楚，因为我没当过厨师，也不会做饭，但最后的一道工序肯定是把米饭和鸡蛋混在一起炒匀。盖浇饭呢，则是把米饭和盖菜分别做好，你如果要一份红烧肉盖饭呢，就给你浇一份红烧肉；如果要一份青椒土豆盖浇饭，就给浇一份青椒土豆丝。
 
蛋炒饭的好处就是入味均匀，吃起来香。如果恰巧你不爱吃鸡蛋，只爱吃青菜的话，那么唯一的办法就是全部倒掉，重新做一份青菜炒饭了。盖浇饭就没这么多麻烦，你只需要把上面的盖菜拨掉，更换一份盖菜就可以了。盖浇饭的缺点是入味不均，可能没有蛋炒饭那么香。
 
到底是蛋炒饭好还是盖浇饭好呢？其实这类问题都很难回答，非要比个上下高低的话，就必须设定一个场景，否则只能说是各有所长。如果大家都不是美食家，没那么多讲究，那么从饭馆角度来讲的话，做盖浇饭显然比蛋炒饭更有优势，他可以组合出来任意多的组合，而且不会浪费。
 
盖浇饭的好处就是"菜"“饭"分离，从而提高了制作盖浇饭的灵活性。饭不满意就换饭，菜不满意换菜。用软件工程的专业术语就是"可维护性"比较好，“饭” 和"菜"的耦合度比较低。蛋炒饭将"蛋”“饭"搅和在一起，想换"蛋”"饭"中任何一种都很困难，耦合度很高，以至于"可维护性"比较差。软件工程追求的目标之一就是可维护性，可维护性主要表现在3个方面：可理解性、可测试性和可修改性。面向对象的好处之一就是显著的改善了软件系统的可维护性。
 　　
 看了这篇文章，简单的总结一下!
 
面向过程
 
 
 
优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、 Linux/Unix等一般采用面向过程开发，性能是最重要的因素。
 缺点：没有面向对象易维护、易复用、易扩展
 
 
面向对象
 
 
 
优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统 更加灵活、更加易于维护
 缺点：性能比面向过程低
 

面向对象：面向对象是相对于面向过程来说的，面向过程是一种以“过程”为中心的编程思想，分析出解决问题所需的步骤，然后用函数把这些步骤一步步的实现，使用的时候一个个依次调用就好。而面向对象，是一种以“对象”为中心的编程思想，把问题看成一个个对象，通过对象的属性和行为，将问题解决的。面向过程强调的是模块化，而面向对象强调的是把事物对象化。
复杂来说面向对象是以“对象”为基本单元构建系统，对象是把数据和数据操作方法放在一起，作为一个相互依存的整体。把同类的对象抽象出其共性，形成类。所以说类是对象的抽象，对象是类具体化的体现（类是大范围的，一个类可以有多个对象），类中的大多数数据只能通过本类的方法实现，类包含说明和实现，说明部分被外界所看到，通过简单的外部接口与外界进行联系；实现部分不被外界所看到，在内部通过不同方法的构建，实现不同的功能。对象与对象之间通过消息进行沟通，程序流程由用户在使用中决定。
面向对象用以解决越来越复杂的需求，提高了软件的重用性，灵活性和拓展性。

面向对象概念
 
在学习面向对象之前，我们可以先了解一下面向过程。面向过程是一种思想，意思是我们要做任何事，都需要亲力亲为，强调的是过程。
 面向对象也是一种编程思想，相对于面向过程，我们可以由原来问题的执行者变为指挥者，进而把生活中很多复杂的问题变得简单化。
 
面向过程强调的是过程,比如,把大象装冰箱,一共分3步:
 第1步：打开冰箱门
 第2步：把大象放进去
 第3步：关上冰箱门
 而面向对象强调的是结果,比如:
 什么样的冰箱?什么样的大象?谁负责把大象装进去?
 有没有发现，如果是面向对象的话，干这件事的主体并不是你自己，你变成了一个指挥者？
 
再比如，衣服脏了，我们可以让女盆友帮忙洗，不需要关注中间过程是怎么洗的，就可以拿到干净的衣服，当然，这首先需要有一个对象（加油哦）~
 
还有，当我们想吃一道菜,其实并不需考虑这道菜是怎么做的,怎么送达的，只需点菜即可.传菜和做菜都有具体的对象来完成具体的功能.我们不需要关注实现的过程,只需要关注结果就好。
 
 
这就是我们所说的面向对象的编程思想（OOP，Object Oriented Programming）
 
如果面试官问什么是面向对象？你答万物皆对象！额，不建议这样做哈，因为我们还没到大佬的这个高度，还是最好举例。
 就像是你说 : 空即是色 色即是空…信你个鬼鬼
 
2 面向对象的三大特征
 
封装: 把相关的数据封装成一个“类”组件
继承: 是子类自动共享父类属性和方法，这是类之间的一种关系
多态: 增强软件的灵活性和重用性
 
3 类和对象
 
3.1 类
 
Java语言最基本单位就是类，类似于类型。
类是一类事物的抽象。
可以理解为模板或者设计图纸。
 
3.2 对象
 
每个对象具有三个特点：对象的状态，对象的行为和对象的标识。
 
对象的状态用来描述对象的基本特征。
对象的行为用来描述对象的功能。
对象的标识是指对象在内存中都有一个唯一的地址值用来和其他对象区分开来。
类是一类事物的抽象，对象是具体的实现。
 
3.3 类和对象的关系
 
计算机语言来怎么描述现实世界中的事物的? 属性 + 行为
那怎么通过java语言来描述呢?
 我们可以通过类来描述一类事物,用成员变量描述事物的属性,用方法描述事物的行为.
 
3.4 练习：类的创建使用
 
在编写代码之前,我们需要分析下需求:
 比如我们要把手机这一类事物抽象成代码：
 那么这个事物的类型就是"手机",可以用类来描述.
 类中包含的就是手机抽取出来的共性的属性与功能.
 
手机的属性：颜色，尺寸，品牌，价格
 手机的功能功能：打电话，发短信，听音乐
 
对象：除此之外,我们还可以创建对象,就相当于是照着图纸制造出来的一个个的手机,比如1号手机对象，包含特有的成员变量和方法
 我们通过class关键字创建类，通过new关键字创建对象。
 接下来我们开始编码吧!
 创建包: cn.tedu.oop
 创建类: TestCreateClass.java
 
package cn.tedu.oop;
/**本类用来练习面向对象
 * 分析手机事物:--通过类来描述
 * 属性:品牌 价格 尺寸 颜色
 * 功能:打电话 发短信 听直播
 * */
//在一个java文件中可以写多个class,但是被public修饰的只能有一个,而且这个类的名字就是文件名
public class TestCreateClass {
	public static void main(String[] args) {
		//2.在main()中通过new关键字来创建对应类的对象
		Phone p = new Phone();
		//3.通过.来完成对象功能的调用
		p.call();
		p.message();
		p.learn();
		//4.通过.来查看对象的属性值
		System.out.println(p.brand);
		System.out.println(p.price);
		System.out.println(p.size);
		System.out.println(p.color);
		
	}
}
//1.通过class关键字创建手机类--用来描述手机这一类事物--特征+行为
//类是一类事物的抽象,只抽象的规定这一类事物的特征和行为
class Phone{
	//特征(属性)--类的成员变量来描述--位置:类里方法外
	String brand;//品牌
	double price;//价格
	double size;//尺寸
	String color;//颜色
	
	//行为(功能)--类的方法来描述--修饰符 返回值类型 方法名(参数列表){方法体}
	public void call() {
		System.out.println("正在打电话");
	}
	public void message() {
		System.out.println("正在发短信");
	}
	public void learn() {
		System.out.println("正在看直播");
	}
}
 
3.5 对象在内存中的存储
 
Java把内存分成5大区域，我们重点关注栈和堆。
 
一般来讲局部变量存在栈中，方法执行完毕内存就被释放
对象(new出来的东西)存在堆中，对象不再被使用时，内存才会被释放
每个堆内存的元素都有地址值
对象中的属性都是有默认值的
 TIPS: 栈与队列指的是一种数据的结构。
 栈：先进后出（FILO – First In Last Out）
 队列：先进先出（FIFO – First In First Out）
 
 
 
 
3.6 练习2：创建多个对象
 
package cn.tedu.oop;
/**本类用来练习面向对象
 * 分析手机事物:--通过类来描述
 * 属性:品牌 价格 尺寸 颜色
 * 功能:打电话 发短信 听直播
 * */
//在一个java文件中可以写多个class,但是被public修饰的只能有一个,而且这个类的名字就是文件名
public class TestCreateClass {
	public static void main(String[] args) {
		//2.在main()中通过new关键字来创建对应类的对象
		Phone p = new Phone();
		//3.通过.来完成对象功能的调用
		p.call();
		p.message();
		p.learn();
		//4.通过.来查看对象的属性值
		System.out.println(p.brand);
		System.out.println(p.price);
		System.out.println(p.size);
		System.out.println(p.color);
		
		//5.创建第二个对象
		Phone p2 = new Phone();
		
		//5.1调用模板里的功能
		p2.call();
		p2.message();
		p2.learn();
		
		//5.2给对象的属性设置值
		p2.brand = "HUAWEI";
		p2.price = 8888.88;
		p2.size = 5.6;
		p2.color = "中国红";
		
		//5.3通过.来查看对象的属性值
		System.out.println(p2.brand);
		System.out.println(p2.price);
		System.out.println(p2.size);
		System.out.println(p2.color);
		
	}
}
//1.通过class关键字创建手机类--用来描述手机这一类事物--特征+行为
//类是一类事物的抽象,只抽象的规定这一类事物的特征和行为
class Phone{
	//特征(属性)--类的成员变量来描述--位置:类里方法外
	String brand;//品牌
	double price;//价格
	double size;//尺寸
	String color;//颜色
	
	//行为(功能)--类的方法来描述--修饰符 返回值类型 方法名(参数列表){方法体}
	public void call() {
		System.out.println("正在打电话");
	}
	public void message() {
		System.out.println("正在发短信");
	}
	public void learn() {
		System.out.println("正在看直播");
	}
}
 

 p2.brand = “HUAWEI”;
 就是先到栈内存中找到p2中保存的唯一的地址值
 然后根据地址值找到对应的Phone对象,并对其对应的属性值进行修改
 p2.eat();
 也是先到栈内存中找到p2中保存的唯一的地址值
 然后根据地址值找到对应Phone对象,执行Phone对象的eat()方法
 
4 封装
 
4.1 概述
 
封装是隐藏对象的属性和实现细节,仅仅对外提供公共的访问方式,比如类和方法
 好处:
 
提高安全性
提高重用性
 
4.2 private关键字
 
是一个权限修饰符 ,可以用来修饰成员变量和成员方法.被私有化的成员只能在本类中访问
 
4.3.1练习：封装的必要性
 
创建包: cn.tedu.oop
 创建类: TestPrivate1.java
 
package cn.tedu.oop;
/*本类用于测试封装的必要性*/
public class TestPrivate1 {
    public static void main(String[] args) {
        //5.创建对象进行测试
        User u = new User();
        u.name = "西门庆";
        System.out.println(u.name);
        //需要封装属性，如果不封装的话，就可以直接修改属性的值
        //不需要按照我们预先设置好的方式也能操作
        //u.money = 1000000;
        //System.out.println(u.money);
        u.setMoney(109999);
        System.out.println(u.queryMoney());

    }
}
//1.创建一个用户类User
class User{
    //2.定义用户类的属性
    public String name;
    private double money = 10000;

    //3.提供方法1:可以用来查询当前账户的余额
    public double queryMoney(){
        /*后续可以添加权限的校验*/
        return money;
    }
    //4.提供方法2：可以设置当前账户的余额
    public void setMoney(double money){
        /*后续可以添加权限的校验*/
        this.money = money;
    }
}
 
4.3.2 练习：封装学生案例
 
创建包: cn.tedu.oop
 创建类: TestPrivate2.java
 
package cn.tedu.oop;
/*本类用于测试面向对象第一大特性--封装*/
public class TestPrivate2 {
    public static void main(String[] args) {
        //4.创建学生类对象s
        Student s = new Student();
        //5.通过对象操作学生类的属性与方法
        System.out.println(s.name);//null
        s.study();//正在学习中。。。
        /*2.subject属性在Student类中被private修饰，所以此处无法直接修改或获取值*/
        //s.subject = "Java培优";
        //System.out.println(s.subject);//Java培优
        //6.3在main()里操作subject属性
        s.setSubject("CGB");//设置值
        System.out.println(s.getSubject());//获取值
        //7.3操作属性sno
        s.setSno(1);
        int snumber = s.getSno();
        System.out.println("接到的学号是："+snumber);
        System.out.println(s.getSno()+"直接打印的");
    }

}

//1.描述学生这一类型
class Student{
    //2.特征：学号 姓名 科目--成员变量/属性
    //7.1封装属性，用private修饰这个属性
    private int sno;//学号
    String name;//姓名
    /*1.private是一个修饰符，被它修饰的资源只能在本类中使用，是权限最小的修饰符*/
    //6.1封装subject属性
    private String subject;//科目

    //7.2添加sno属性对应的get()与set()
    public int getSno() {
        return sno;
    }
    public void setSno(int sno) {
        this.sno = sno;
    }

    //6.2我们需要提供一个公共的方式，供外界操作subject的属性值
    //右键空白处->Generate->Getter and Setter->选中subject属性->OK
    public String getSubject() {
        /*4.如果一个方法需要返回结果，那么这个方法定义的返回值类型就不再是void了
        * 至于具体设置成什么类型，与返回值的类型保持一致
        * 比如我们要返回的subject是String类型，所以方法的返回值类型为String
        * 返回值通过关键字return进行返回*/
        return subject;
    }
    public void setSubject(String subject) {
        /*3.如果一个类中的成员变量与局部变量同名
        * 需要使用this关键字指定，我们规定this指定的那个是成员变量*/
        this.subject = subject;
    }

    //3.功能：学习 吃饭 睡觉--方法
    public void study(){
        System.out.println("正在学习中。。。");
    }
    public void eat(){
        System.out.println("正在吃饭ing...");
    }
    public void sleep(){
        System.out.println("我一点也不想睡觉，就想学Java！");
    }
}
 
TIPS:如何封装?封装后的资源如何访问?
 我们可以使用private关键字来封装成员变量与方法
 如何访问私有资源?
 关于成员变量:
 setXxx – 对外提供公共的设置值方式
 getXxx – 对外提供公共的获取值方式
 关于成员方法:
 把私有方法放在公共方法里供外界调用即可
 
5 拓展：OOP综合练习
 
创建包：cn.tedu.oop
 创建类：TestCar
 
package cn.tedu.oop;
/*本类用于面向对象的巩固练习*/
public class TestCar {
    //创建程序的入口函数main()
    public static void main(String[] args) {
        //3.创建汽车类对象c
        Car c = new Car();
        //4.通过汽车类对象c设置属性值
//        c.color = "暗夜紫";
//        c.brand = "BMW";
//        c.price = 200;
//        c.length = 0.2;
        //5.查看刚刚设置好的属性值
//        System.out.println(c.brand);
//        System.out.println(c.price);
//        System.out.println(c.color);
//        System.out.println(c.length);
        //6.通过c对象调用汽车类的方法
        c.start();
        //c.stop();
        //7.3调用提供的set与get方法，设置并获取对应属性的值
        c.setBrand("特斯拉");
        c.setColor("black");
        c.setPrice(200.02);
        c.setLength(3);
        System.out.println(c.getBrand());
        System.out.println(c.getColor());
        System.out.println(c.getLength());
        System.out.println(c.getPrice());
        //8.3 调用公共方法来实现私有方法功能的使用
        c.start();
    }
}
//1.抽象汽车这一类事物的属性与行为，封装成一个类组件
class Car{
    //2.属性--用成员变量来描述
    //7.1封装所有的属性值--使用private修饰
    private String color;
    private String brand;
    private double price;
    private double length;
    //7.2 生成所有属性的get与set方法
    /*右键空白处->Generate->Getter and Setter->按住Shift全选所有属性生成即可*/
    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public double getLength() {
        return length;
    }

    public void setLength(double length) {
        this.length = length;
    }

    //3.行为--用方法来描述
    //8.2 可以在本类公共的方法里，调用私有方法
    public void start(){
        System.out.println("汽车开动了~");
        stop();//我们通过方法名+参数列表确定要调用哪个方法
    }
    //8.1封装方法，通过private修饰符
    private void stop(){
        System.out.println("汽车停止了~");
    }
}
 
6 访问控制符
 
用来控制一个类，或者类中的成员的访问范围。
 
 TIPS:default是表示不写修饰符,默认,如果写default单词来修饰会报错
 
拓展7 匿名对象
 
没有名字的对象，是对象的简化表示形式。
 使用场景：
 当被调用的对象只调用一次时（多次会创建多个对象浪费内存）
 Demo d = new Demo();
 d.sleep();
 d.game();
 //这个d就是对象的名字。
 也可以写成：
 new Demo().show();//创建了一个对象调方法
 new Demo().game();//又创建了一个对象调方法

面向对象就是：把数据及对数据的操作方法放在一起，作为一个相互依存的整体——对象。对同类对象抽象出其共性，形成类。类中的大多数数据，只能用本类的方法进行处理。类通过一个简单的外部接口与外界发生关系，对象与对象之间通过消息进行通信。程序流程由用户在使用中决定。对象即为人对各种具体物体抽象后的一个概念，人们每天都要接触各种各样的对象，如手机就是一个对象。
 
面向对象编程（OOP： object-oriented programming）
 
 
 

  
  
 
 
 
 
面向对象与面向过程的区别
 
项目名称
面向对象程序设计
面向过程程序设计（也叫结构化编程）
定义
面向对象顾名思义就是把现实中的事务都抽象成为程序设计中的“对象”，其基本思想是一切皆对象，是一种“自下而上”的设计语言，先设计组件，再完成拼装。
面向过程是“自上而下”的设计语言，先定好框架，再增砖添瓦。通俗点，就是先定好main()函数，然后再逐步实现mian()函数中所要用到的其他方法。
特点
封装、继承、多态
算法+数据结构
优势
适用于大型复杂系统，方便复用、
适用于简单系统，容易理解
劣势
比较抽象、性能比面向过程低
难以应对复杂系统，难以复用，不易维护、不易扩展
对比
易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统 更加灵活、更加易于维护 
性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、 Linux/Unix等一般采用面向过程开发，性能是最重要的因素。 
设计语言
Java、Smalltalk、EIFFEL、C++、Objective-、C#、Python等
C、Fortran
使用场景
 
30种编程语言的比较选择问题https://blog.csdn.net/ljy1988123/article/details/7782700
 
类与对象的主要区别
 
对象：对象是类的一个实例（对象不是找个女朋友），有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。 
 
类：类是一个模板，它描述一类对象的行为和状态。
 
1、面向对象三大主要特征（理解）
 
①封装
 
两层含义：一层含义是把对象的属性和行为看成一个密不可分的整体，将这两者“封装”在一个不可分割的独立单元(即对象)中；另一层含义指“信息隐藏”，把不需要让外界知道的信息隐藏起来，有些对象的属性及行为允许外界用户知道或使用，但不允许更改，而另一些属性或行为，则不允许外界知晓，或只允许使用对象的功能，而尽可能隐藏对象的功能实现细节。
 
封装的优点
 
 
良好的封装能够减少耦合，符合程序设计追求“高内聚，低耦合”。
 
 
类内部的结构可以自由修改。
 
 
可以对成员变量进行更精确的控制。
 
 
隐藏信息实现细节。
 
实现Java封装的步骤
 
1. 修改属性的可见性来限制对属性的访问（一般限制为private），例如：
 
public class Person { 
    private String name; 
    private int age; 
}
 
这段代码中，将 name 和 age 属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。
 
2. 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问，例如：
 
public class Person{ 
    private String name;
    private int age; ​ 
    private boolean alive;

    public int getAge(){
        return age; 
    } 

    public void setAge(int age){ 
        this.age = age; 
    } ​

    public String getName(){ 
        return name; 
    } ​
 
    public void setName(String name){ 
        this.name = name; 
    }

    public boolean isAlive() {
		return alive;
	}

	public void setAlive(boolean alive) {
		this.alive = alive;
	}

}
 
采用 this 关键字是为了解决实例变量（private String name）和局部变量（setName(String name)中的name变量）之间发生的同名的冲突。
 
封装同时可以提高代码的安全性，例如普通的类属性不是private修饰就直接可以通过“对象名.属性 = xxx”对其赋值，但当我们用private修饰该属性后就不能这样对其做任意的修改了，而且我们还可以在其对外的访问方法中进行合法值校验。比如上例中的setAge()就可以更改为：
 
public void setAge(int age){
    if(age > 120)
        System.out.println("Age setting error");
    else
        this.age = age;
}
 
 封装的使用细节：
 
一般使用private访问权限
提供相应的get、set方法来访问相关属性，这些方法通常是public修饰的。以提供对属性的赋值与读取操作。（注意！boolean变量的get方法是is开头。）
一些只用于本类的辅助性方法，可以使用private修饰，希望其他类调用的方法用public修饰。
this与super关键字：
 
1、this关键字代表当前对象
 
2、super可以理解为是指向自己超（父）类对象的一个指针，而这个超类指的是离自己最近的一个父类。  
 
 this与super对比
 
this.属性 操作当前对象的属性
this.方法 调用当前对象的方法 
引用构造函数：调用本类中另一种形式的构造函数（应该为构造函数中的第一条语句）。
普通的直接引用：与this类似，super相当于是指向当前对象的父类，这样就可以用super.xxx来引用父类的成员。
子类中的成员变量或方法与父类中的成员变量或方法名同名时，表示调用父类的成员
引用构造函数：调用父类中的某一个构造函数（应该为构造函数中的第一条语句）。默认在构造函数第一条语句是“super();”，无论写与否。
super(参数)：调用基类中的某一个构造函数（应该为构造函数中的第一条语句）
this(参数)：调用本类中另一种形成的构造函数（应该为构造函数中的第一条语句）
调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用 super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。
super() 和 this() 类似,区别是，super() 从子类中调用父类的构造方法，this() 在同一类内调用其它方法。
super() 和 this() 均需放在构造方法内第一行。
尽管可以用this调用一个构造器，但却不能调用两个。
this 和 super 不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有 super 语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。
this() 和 super() 都指的是对象，所以，均不可以在 static 环境中使用。包括：static 变量,static 方法，static 语句块。
从本质上讲，this 是一个指向本对象的指针, 然而 super 是一个 Java 关键字。
②继承
 
继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。
 
继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
 
类的继承格式：
 
class 父类 { }
 
class 子类 extends 父类 { }
 
继承的类型：需要注意的是 Java 不支持多继承，但支持多重继承。
 
 
 继承的好处：
 
(1)提高类代码的复用性
 
(2)提高了代码的维护性
 
(3)使得类和类产生了关系，是多态的前提(它也是继承的一个弊端，类的耦合性提高了)
 
继承的特性
 
 
子类拥有父类非 private 的属性、方法。
 
 
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
 
 
子类可以用自己的方式实现父类的方法，即重写父类方法。
 
 
Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 A 类继承 B 类，B 类继承 C 类，所以按照关系就是 C 类是 B 类的父类，B 类是 A 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
 
 
继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类。
 
 
提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。
 
 final关键字：
 
表示最终的意思，可以修饰类、成员变量、成员方法
 
修饰类：类不可以被继承
修饰成员变量：变量为常量，值不可以改变
修饰成员方法：方法不能被重写
final还可以修饰局部变量：①修饰基本数据类型，值不能改变；②修饰引用数据类型，地址值不能改变
 static关键字（静态）：
 
static表示静态的意思，既可以修饰成员变量，又可以修饰成员方法，还有一种特殊用法修饰类
 
(1)、修饰成员变量表示静态变量：static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。static成员变量的初始化顺序按照定义的顺序进行初始化。static不能修饰局部变量。
 
(2)、修饰成员方法：static方法一般称作静态方法，由于静态方法不依赖于任何对象就可以进行访问，因此对于静态方法来说，是没有this的，因为它不依附于任何对象，既然都没有对象，就谈不上this了。并且由于这个特性，在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。
 
(3)static代码块：static关键字还有一个比较关键的作用就是 用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。
 
特点：
     1）随着类的加载而加载
     2）优先于对象存在
     3）被所有的对象所共享
         该特点是我们使用static的条件
 
注意事项：
     1）在静态方法中，不能出现this／super
     2）静态方法只能访问静态成员；非静态方法既可以访问静态成员，也可以访问非静态成员
     3）工具类里面的成员一般来说是静态成员（目的：节约内存空间）
 
静态变量和成员变量的区别
 1）所属不同
       静态变量属于类，也称为类变量
       成员变量属于对象，也称为实例变量
 2）内存中位置不同
       静态变量存在方法区
       成员变量存在堆中
 3）出现的时间不同
       静态变量随着类的加载而加载，随着类的消亡而消亡
       成员变量随着对象的创建而创建，随着对象的消失而消失
 4）调用方式不同
       静态变量通过类名调用，也可以通过对象名调用（不建议）
       成员变量只能通过对象名调用
 所以，成员变量可以称为对象的特有数据，静态变量称为对象的共享数据
 
成员变量与局部变量的区别
 1）在类中的位置不同
        成员变量：在类中方法外面
        局部变量：在方法或者代码块中，或者方法的声明上（即在参数列表中）
 2）在内存中的位置不同，可以看看Java程序内存的简单分析
        成员变量：在堆中（方法区中的静态区）
        局部变量：在栈中
 3）生命周期不同
       成员变量：随着对象的创建而存在，随着对象的消失而消失
       局部变量：随着方法的调用或者代码块的执行而存在，随着方法的调用完毕或者代码块的执行完毕而消失
 4）初始值
       成员变量：有默认初始值
       局部变量：没有默认初始值，使用之前需要赋值，否则编译器会报错（The local variable xxx may not have been initialized）
 
package se01.day02;

//子父类静态代码块、构造代码块、构造方法
class Fu{
	String name;
	int age;
	
	{
		System.out.println("构造代码块Fu");
	}
	
	static{
		System.out.println("静态代码块Fu");
	}
	
	public Fu() {
		System.out.println("无参构造方法Fu");
	}

	public Fu(String name, int age) {
		this.name = name;
		this.age = age;
		System.out.println("有参构造Fu");
	}

}
public class Zi extends Fu{
	int id;
	{
		System.out.println("构造代码块Zi");
	}
	static{
		System.out.println("静态代码块Zi");
	}
	public Zi() {
		System.out.println("无参构造方法Zi");
	}

	public Zi(String name, int age) {
		this.name = name;
		this.age = age;
		System.out.println("有参构造Zi");
	}
	public static void main(String[] args) {
		new Zi("小明",13);
	}
}

==========================执行结果为====================================
静态代码块Fu
静态代码块Zi
构造代码块Fu
无参构造方法Fu
构造代码块Zi
有参构造Zi
 
static特殊用法(static修饰类)：  如果一个类要被声明为static的，只有一种情况，就是静态内部类。如果在外部类声明为static，程序会编译都不会过。（在内部类中详细讲解）
 
Question：在什么情况下需对属性和方法加上static关键字？
 
在编写的代码中，static定义的属性出现几率不是特别高，一般只有在描述共享属性概念或者是不受实例化对象限制的属性时才会使用static定义属性，而大部分情况下依然都使用非static属性。
 
产生实例化对象是因为在堆内存中可以保存属性信息，所以如果一个类中没有属性产生，就自然也没有必要去开辟堆内存保存属性内容了，所以这个时候就可以考虑类中的方法全部使用static声明。
 
NOTICE:在JDK1.7之前，Java一直存在一个Bug，可以先执行静态代码块来代替主方法。按照标准来说，所有的程序应该都是从主方法开始执行，但是下例却先执行静态代码块
 
	public static void main(String[] args) {
		System.out.println("你好,世界");
	}
	
	static{
		System.out.println("Hello World");
	}

===========输出结果为==============
Hello World
你好,世界
 
③多态
 
多态是同一个行为具有多个不同表现形式或形态的能力。
 
 
 

  
  
 
 
Java语言中含有方法重载与对象多态两种形式的多态：
 
方法重载：在一个类中，允许多个方法使用同一个名字，但方法的参数不同，完成的功能也不同。
 
对象多态：子类对象可以与父类对象进行转换，而且根据其使用的子类不同完成的功能也不同（重写父类的方法）。
 
面试题：什么是多态？实现多态的方法有哪些？
 
多态是面向对象的最后一个主要特征，它本身主要分为两个方面：
        ·方法的多态性：重载与覆写
             |-重载：同一个方法名称，根据不同的参数类型及个数可以完成不同的功能。
             |-覆写：同一个方法，根据操作的子类不同，所完成的功能也不同。
        ·对象的多态：父子类对象的转换。
             |-向上转型：子类对象变为父类对象，格式：父类 父类对象 = 子类实例，自动；
             |-向下转型：父类对象变为子类对象，格式：子类 子类对象 = (子类)父类实例，强制。
 
多态的优点
 
1. 消除类型之间的耦合关系
2. 可替换性
3. 可扩充性
4. 接口性
5. 灵活性
6. 简化性
多态存在的三个必要条件
 
继承
重写
父类引用指向子类对象
比如：Parent p = new Child();
 
多态的访问方式：
 (1)成员变量
     编译看左边，运行看左边
 (2)成员方法
     编译看左边，运行看右边
 (3)静态方法
     编译看左边，运行看左边
 
多态的实现方式
 
方式一：重载与重写：
 
这个内容已经详细讲过，就不再阐述，详细请见上文。
 
方式二：抽象类和抽象方法
 
在Java中，一个没有方法体的方法称为抽象方法。而一个类中如果有抽象方法，那么这个类就称之为抽象类。
 
格式：
     抽象类：abstract class 类名{}
     抽象方法：修饰符 abstract 返回值类型 方法名(参数列表){方法体;}
 
特点：
     1）抽象类不一定有抽象方法，但是有抽象方法的类一定是抽象类
     2）抽象类不可以实例化(不能用new关键字创建抽象类实例)
     3）抽象类的子类，可以是抽象类，也可以是具体类。如果子类是具体类，需要重写抽象类里面所有抽象方法
 
组成：
     1）成员变量
         可以是变量，可以是常量
     2）构造方法
         有构造方法
         抽象类不可以实例化，存在构造方法，有什么用？
         子类会调用父类的构造方法，对属性进行初始化赋值
     3）成员方法
         可以是抽象方法，也可以是具体方法
 
抽象(abstract)不能与那些关键字共存？
 1).private :因为一个abstract方法需要被重写，所以不能修饰为private;
 2).final:因为一个abstract方法需要被重写。被final修饰的方法是不能被重写的，所以不能同final共存；
 3).static:因为一个abstract方法没有方法体。静态方法需要对方法体执行内容分配空间，所以不能同static共存；（abstract是没有实现  的，不能产生对象，而是static是属于类的，类本身是已经存在的对象）
 4).synchronized: 是同步的，然而同步需要具体的操作才能同步，但， abstract是只有声明没有实现的（即，使用synchronized关键字的是需要有具体的实现同步的操作的，但是使用abstract是只有声明而没有实现的，这样就产生了冲突）
 5).native:他们本身的定义就是冲突的，native声明的方法是移交本地操作系统实现的，而abstract是移交子类对象实现的，同时修饰的话，导致不知道谁实现声明的方法
 
方式三：接口
 
接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。实际上是一个规范，它会要求你做什么，但不会要求你去怎么做。接口里面定义的是额外功能，但是不给出具体的实现。
 
接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。
 
接口与类相似点：
 
一个接口可以有多个方法。
接口文件保存在 .java 结尾的文件中，文件名使用接口名。
接口的字节码文件保存在 .class 结尾的文件中。
接口相应的字节码文件必须在与包名称相匹配的目录结构中。
接口与类的区别：
 
接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法。
接口不能包含成员变量，除了 static 和 final 变量。
接口不是被类继承了，而是要被类实现。
接口支持多继承。
接口特性：
 
接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。
抽象类和接口的区别：
 
1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。
接口的多继承
 
接口和接口继承关系，可以单继承，多继承，多级继承
 
标记接口
 
标记接口是没有任何方法和属性的接口.它仅仅表明它的类属于一个特定的类型,供其他代码来测试允许做一些事情。
 
Java中的标记接口有：
 
java.io.Serializable这个接口是用来标记类是否支持序列化的,所谓的序列化就是将对象的各种信息转换成可以存储或者传输的一种形式。如果一个类没有实现该接口，却被拿去序列化的了，那么虚拟机就会抛出不支持序列化的异常
Cloneable接口在深度拷贝的时候经常被用到，在调用java.lang.Object类中clone方法的过程中，如果对象没有实现Cloneable接口，那么虚拟机就会抛出一个CloneNotSupportedException异常。
java.util.RandomAccess这个接口的作用是判断集合是否能快速访问，也就是通过索引下标能否快速的移动到对应的元素上。我们在使用某个集合类中，集合中的元素可以通过索引index下标快速的访问到，那么在该类的定义处，一般会有一个RandomAccess接口的实现标签。 
比如:java.util.ArrayList<E>有这个接口，java.util.LinkedList<E>就没有
 
1 public class ArrayList<E> extends AbstractList<E>
2         implements List<E>, RandomAccess, Cloneable, java.io.Serializable
3 {
4 //...
5 }
 
1 public class LinkedList<E>
2     extends AbstractSequentialList<E>
3     implements List<E>, Deque<E>, Cloneable, java.io.Serializable
4 {
5     ...
6 }
 
2、数组的使用以及初始化操作
 
数组是用来存储多个相同数据类型值的容器。
 
数组初始化
 1）动态初始化
     只指定数组的长度，由系统分配默认值
     格式：
     数据类型[] 数组名 = new 数据类型[长度];     或者      数据类型 数组名[] = new 数据类型[长度]
     默认值：
     byte、short、int、long,默认0
     float、double,默认0.0
     boolean,默认false
     char,默认'\u0000'
     String,默认null（所有引用数据类型默认都是null）
 2）静态初始化
     指定数组里面每个元素的初始值，不指定数组的长度
     格式：
         数据类型[] 数组名 = new 数据类型[]{元素1,元素2...};
     简写：
         数据类型[] 数组名 = {元素1,元素2...};
 
简单实例：
 
public static void main(String[] args) {
		  double[] myList = {1.9, 2.9, 3.4, 3.5};
		  
	      // 打印所有数组元素
	      for (int i = 0; i < myList.length; i++) {
	         System.out.print(myList[i] + " ");
	      }
	      System.out.println("\n=================");
	      for (double d : myList) {
			System.out.print(d + " ");
		}
	      System.out.println("\n=================");
	      // 计算所有元素的总和
	      double total = 0;
	      for (int i = 0; i < myList.length; i++) {
	         total += myList[i];
	      }
	      System.out.println("Total is " + total);
	      // 查找最大元素
	      double max = myList[0];
	      for (int i = 1; i < myList.length; i++) {
	         if (myList[i] > max) max = myList[i];
	      }
	      System.out.println("Max is " + max);
	}


运行结果：
1.9 2.9 3.4 3.5 
=================
1.9 2.9 3.4 3.5 
=================
Total is 11.7
Max is 3.5
 
 冒泡排序（相邻的元素进行比较，大值往后排）：
 
	public static void bubbleSort(int[] arr){
		int temp = 0;
		for (int i = 0; i < arr.length-1; i++) {
			for (int j = 0; j < arr.length-1-i; j++) {
				if(arr[j]>arr[j+1]){
					temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
	}
 
 选择排序（前面元素与后面的元素诸葛逐个进行比较，小值往前排）：
 
	public static void selectSort(int[] arr){
		int temp = 0;
		for (int i = 0; i < arr.length-1; i++) {
			for (int j = i+1; j < arr.length; j++) {
				if(arr[i]>arr[j]){
					temp = arr[i];
					arr[i] = arr[j];
					arr[j] = temp;
				}
			}
		}
		System.out.println(Arrays.toString(arr));
	}
 
 多维数组
 
多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组，例如：
 
String str[][] = new String[3][4];
 
多维数组初始化的方式与一维数组初始化方式类似，也分动态和静态两种方式。
 
不规则数组
 
“ 不规则 ” 数组 ， 即数组的每一行有不同的长度。典型的案例是杨辉三角
 
//不规则数组，杨辉三角
public class LotteryArray {
	public static void main(String[] args) {
		final int NMAX = 10; //最大行数
		int[][] odds = new int[NMAX][];
		for (int n = 0; n < NMAX; n++)
			odds[n] = new int[n + 1]; //初始化，开辟空间
		for (int n = 0; n < odds.length; n++) {
			for (int k = 0; k < odds[n].length; k++) {
				/*
				 * int lotteryOdds = 1;
				 * for (int i = 1; i <= k; i++) 
                                 *     lotteryOdds = lotteryOdds * (n - i + 1) / i;
				 * odds[n][k] = lotteryOdds;
				 */
				// 第一个和最有一个都是1，其余的都是它的上一个和它的上一个的前一个的和
				if (k == 0 || k == odds[n].length - 1) {
					odds[n][k] = 1;
				} else {
					odds[n][k] = odds[n - 1][k - 1] + odds[n - 1][k];
				}

			}
		}
		for (int[] row : odds) {
			for (int odd : row)
				System.out.printf("%4d", odd);
			System.out.println();
		}

	}
}


=======================结果显示============================
   1
   1   1
   1   2   1
   1   3   3   1
   1   4   6   4   1
   1   5  10  10   5   1
   1   6  15  20  15   6   1
   1   7  21  35  35  21   7   1
   1   8  28  56  70  56  28   8   1
   1   9  36  84 126 126  84  36   9   1
 
数组工具类Arrays
 
修饰符和类型
方法和描述
static <T> List<T>
 
asList(T... a)
 
返回由指定数组支持的固定大小的列表。
 
static int
 
binarySearch(byte[] a, byte key)
 
使用二进制搜索算法在指定的字节数组中搜索指定的值。
 
static int
 
binarySearch(byte[] a, int fromIndex, int toIndex, byte key)
 
使用二进制搜索算法搜索指定值的指定字节数组的范围。
 
char[]、double[]、float[]、int[]、long[]、Object[]、short[]...同样适用
 
static boolean[]
 
copyOf(boolean[] original, int newLength)
 
使用false复制指定的数组，截断或填充（如果需要），以使副本具有指定的长度。
 
static byte[]
 
copyOf(byte[] original, int newLength)
 
使用零复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。
 
char[]、double[]、float[]、int[]、long[]...同样适用
 
static char[]
 
copyOfRange(boolean[] original, int from, int to)
 
将指定数组的指定范围复制到新数组中。
 
static double[]
 
copyOfRange(boolean[] original, int from, int to)
 
将指定数组的指定范围复制到新数组中。
 
boolean[]、char[]、float[]、int[]、long[]同样
 
static boolean
equals(boolean[] a, boolean[] a2) 
如果两个指定的布尔数组彼此相等，则 返回true。
 
byte[]、char[]、double[]...同样适用
 
static void
fill(boolean[] a, boolean val) 
将指定的布尔值分配给指定的布尔数组的每个元素。
 
byte[]、char[]、double[]...同样适用
 
static void
parallelSort(byte[] a) 
将指定的数组按升序排序。java8新特性，并行排序。
 
static void
sort(float[] a) 
将指定的数组按升序排序。串行排序。
 
static void
sort(float[] a, int fromIndex, int toIndex) 
按升序对数组的指定范围进行排序。
 
int[]、short[]、long[]、double[]...同样适用
 
static String
toString(boolean[] a) 
返回指定数组内容的字符串表示形式。
 
3、java基本数据类型和引用传递区别
 
简概： ①形参为基本数据类型形参改变，实参不会发生改变
  ②形参为引用数据类型形参改变，实参也会跟着改变（有特例）
 
详述：https://blog.csdn.net/sugar_no1/article/details/86506510