程序员写程序为了什么？
我觉得就是为了帮助我们解决现实存在的问题的。既然是解决现实生活中的问题，那么我们一定需要将现实的东西映射在虚拟世界里。
在最初的编程里，其实是不需要面向对象的，因为最初的编程都很简单，比如做一个计算器之类的，使用基础语法就能实现，到目前为止我们写的代码就是这样的。
但是随着计算机编程的日益复杂化，仅仅使用基本语法很难表述出现实生活的复杂模样，代码大片的堆积会让我们的代码越来越难懂、难以维护。
当前越来越复杂的事物同样需要快速方便的映射在虚拟世界，比如一条泰迪，怎么在虚拟世界里表达呢？用一个字符串能表示吗？可能也行，但是很困难，而且很牵强，因为泰迪有很多特性，比如颜色、公母、它还会叫，会吃。就像我们写的玻璃工厂，不管是啥东西都用String表示，看起来真的很别扭。
我们仔细分析了世上的各种各样的东西，所有的东西不外乎可以表述为”有哪些特点“和”能干什么“。
之前我们学习了方法，方法是将一段代码（有变量，有判断、循环）放在一起，让他去做好一件事情，而对象则是将一些属性（变量）和功能（也就是方法，方法的存在就是为了实现一个功能）组装在一起。然后，我们天然的发现这样去描述一种事物会特别恰当。还是那句话，所有的复杂都是由简单封装而成的，就像世界万物都是由分子构成的一样。而我们的分子就是基本数据类型，就是判断，就是循环。我们唯一做了的，就是把这些东西放在一起就成了方法，进一步把变量和方法放在一起就成了类。
但是实际上，一个对象和基本数据类型一样，都是一个数据块，对象就是封装了一些变量和方法，就是在内存中寻找了一块地址存了一堆数据。就好比，我们把旺旺雪饼，旺旺奶糖等装在一起就是一个旺仔大礼包，我们送人的时候就可以直接提着旺仔大礼包送人，我们使用起来是不是很方便，很体面呢？
举例：
1：狗 他的特点有：颜色是什么颜色， 年龄有多大等。他还能吃、能喝、能叫。
2：手机 他的特点是：内存有多大、屏幕有几寸等。他还能打电话 、能上网、能玩游戏。
3：工厂 他的特点是：人数有多少 、占地面积有多大等 。他能生产产品。
4：太阳 他的特点是：重量有多大 能量有多少等。他能出光照耀太阳系。
同样有些东西可能只有属性，他自己往往不能做什么事情，比如：
1：苹果 他的特点是：味道是酸还是甜 、大小是大还是小、产地是哪里等。
2：酒 他的特点是：年代是哪一年、 品牌是什么牌子、酒精度数是多大。
在java里，我们描述一个种类的东西时，就是使用类，关键字是class。
类是用来描述现实生活中的一类事物的。
上文已经提出描述一类事物 第一要看他有什么特点，java中我们称之为对象的属性。第二看他能干什么，我们称之为对象的方法。所以在java里对象是由属性和方法组成的，而我们写class类的是后就是为了描述这类事物有什么属性和方法的，其中对象和类不是一个概念，下文会介绍。
属性一般是使用基础类型或引用类型描述，在java里属性一般会私有化，使用private关键字，使用setter和getter方法进行取值和赋值(课堂上讲原因)。
而方法就是封装了一些代码逻辑，方法的目的就是做好一件事情，当然在我们定义的类里边，一个方法就是这类事物的一个功能。
如定义狗：
/**
* 定义狗类
* @author zn
* @date 2020/2/2
*/
public class Dog {
//有哪些特点
//定义狗有颜色这个属性
private String color;
//定义狗有种类这个属性
private String type;
//定义狗有年龄这个属性
private int age;
//定义狗会吃，能干什么
public void eat(String foodName){
System.out.println(type+"在吃"+foodName);
}
//java约定使用setter和getter方法进行属性的取值和赋值
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//..狗还有很多属性和方法，我们无法一一列举
}
定义了这个狗类之后，我们要怎么做呢？
java里有个万能的造物者，他叫new，他就能根据我们定义的类，给你创造一个实实在在的东西，这个东西就是对象。如你定义了一个类，描述了汽车的属性，功能（方法），以及怎么制造（构造方法，课上讲），其实这不就是个说明书吗？你就能使用new这个造物者，根据这个class对象制造汽车（实例），可以造一个也可以造多个。
public static void main(String[] args) {
//根据狗类造一个泰迪
Dog teddy = new Dog();
teddy.setType("泰迪");
teddy.eat("骨头");
//根据狗类再造一个金毛
Dog golden = new Dog();
golden.setType("金毛");
golden.eat("肉");
}
结果：
泰迪在吃骨头
金毛在吃肉
感觉好神奇，对不对。
在java里new出来的东西叫对象，也叫实例，就是他被实实在在造出来，而class对象存在的意义就是描述这一个事物。
class就是百度百科里的苹果，只是对苹果做了一个说明
new出来的实例就是你家水果盘里放的那个苹果
百度百科说苹果是甜的，
请问是百度百科是甜的还是你家水果盘里的苹果是甜的？
答案不用我多说
重点：所以在class里定义的属性和方法是属于new出来的对象的，而不是这个类对象本身。除非用static修饰，我们讲过static，他是在类加载的时候直接给了类对象，这一点尤其重要。
还是我们熟悉的镜子工厂，用类怎么表示呢？
镜子工厂.png
首先我们需要将原材料，以及每个车间的产品抽象成程序里的类：
/**
* 抽象一个材料类
* @author zn
* @date 2020/2/1
*/
public class Material {
private String name;
public Material(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
/**
* 抽象出玻璃类和镜框类基本一致
* @author zn
* @date 2020/2/1
*/
public class Glass {
private String type;
public Glass(String type) {
this.type = type;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
}
/**
* 该类是抽象出一个镜框类
* @author zn
* @date 2020/2/1
*/
public class Frame {
//镜框的类型属性，表示什么形状的镜框
private String type;
//使用有参构造方法覆盖无参构造方法，同时将类型赋值
public Frame(String type) {
this.type = type;
}
//为类型提供setter和getter方法
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
}
/**
* 抽象出镜子类
* @author zn
* @date 2020/2/1
*/
public class Mirror {
//镜子是由玻璃和镜框组成的
private Glass glass;
private Frame frame;
public Glass getGlass() {
return glass;
}
public void setGlass(Glass glass) {
this.glass = glass;
}
public Frame getFrame() {
return frame;
}
public void setFrame(Frame frame) {
this.frame = frame;
}
//用一个方法通过玻璃类型来确定生产的玻璃的具体类型
public String getMirrorType(){
if(this.glass.getType().equals("普通玻璃")){
return "带着【" + frame.getType() + "】的普通玻璃镜子！";
}else if(this.glass.getType().equals("钢化玻璃")){
return "带着【" + frame.getType() + "】的钢化玻璃镜子！";
}else{
return "普通的没有任何特点的镜子！";
}
}
}
然后生产车间我们依然需要抽象：
/**
* 抽象出镜框车间类
* @author zn
* @date 2020/2/1
*/
public class FrameWorkShop {
//车间名称
private String name;
//setter和getter
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public FrameWorkShop(String name) {
this.name = name;
}
//该车间有个方法能够生产镜框
public Frame[] productFrame(Material[] materials,String type){
Frame[] frames = new Frame[materials.length];
for (int i = 0; i < materials.length; i++) {
if (materials[i].getName().equals("木材")){
frames[i] = new Frame(type);
}
}
return frames;
}
}
/**
* 抽象出玻璃车间的类
* @author zn
* @date 2020/2/1
*/
public class GlassWorkShop {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public GlassWorkShop(String name) {
this.name = name;
}
//生产普通玻璃的方法
public Glass[] productGlass(Material[] normalMaterials){
Glass[] glasses = new Glass[normalMaterials.length];
for (int i = 0; i < normalMaterials.length; i++) {
glasses[i] = new Glass("普通玻璃");
}
return glasses;
}
//生产钢化玻璃的重载方法
public Glass[] productGlass(Material[] normalMaterials,Material[] otherMaterials){
int glassCount = Math.min(normalMaterials.length, otherMaterials.length);
Glass[] glasses = new Glass[glassCount];
for (int i = 0; i < glassCount; i++) {
glasses[i] = new Glass("钢化玻璃");
}
return glasses;
}
}
/**
* 抽象出镜子车间
* @author zn
* @date 2020/2/1
*/
public class MirrorWorkShop {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public MirrorWorkShop(String name) {
this.name = name;
}
//批量生产镜子的方法
public Mirror[] productMirrors(Glass[] glasses,Frame[] frames){
//获取制造的镜子的数量，取两个数组的最小值,确定镜子的数量
int mirrorCount = Math.min(glasses.length, frames.length);
Mirror[] mirrors = new Mirror[mirrorCount];
for (int i = 0; i < mirrors.length; i++) {
Mirror mirr = new Mirror();
mirr.setFrame(frames[i]);
mirr.setGlass(glasses[i]);
mirrors[i] = mirr;
}
return mirrors;
}
}
最好有个材料中心为我们方便的提供各种原材料：
/**
* 抽象一个材料中心
* @author zn
* @date 2020/2/1
*/
public class MaterialCenter {
//批量生产材料的方法，注意这个是个静态方法，是属于类对象的，使用时不需要new
public static Material[] productMaterial(int count,String type){
Material[] materials = new Material[count];
for (int i = 0; i < count; i++) {
materials[i] = new Material(type);
}
return materials;
}
}
最后销售部负责销售镜子：
/**
* 抽象出销售部的类
* @author zn
* @date 2020/2/2
*/
public class SalesDepartment {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public SalesDepartment(String name) {
this.name = name;
}
//销售镜子的方法
public void saleMirrors(Mirror[] mirrors){
for (int i = 0; i < mirrors.length; i++) {
System.out.println(mirrors[i].getMirrorType() + "被【" + this.name + "】销售了！");
}
System.out.println("镜子被销售一空");
System.out.println("------------------------------------------");
}
}
测试类
/**
* @author zn
* @date 2020/2/1
*/
public class Test {
public static void main(String[] args) {
//新建一个镜框车间
FrameWorkShop frameWorkShop = new FrameWorkShop("镜框车间");
//生产五个方形镜框，其中MaterialCenter.productMaterial(5,"木材")会生产5个木材
Frame[] frames1 = frameWorkShop
.productFrame(MaterialCenter.productMaterial(5,"木材"), "方形边框");
Frame[] frames2 = frameWorkShop
.productFrame(MaterialCenter.productMaterial(5,"木材"), "圆形边框");
//新建一个玻璃车间
GlassWorkShop glassWorkShop = new GlassWorkShop("玻璃车间");
//生产五个普通玻璃
Glass[] glasses = glassWorkShop
.productGlass(MaterialCenter.productMaterial(5,"沙子"));
//生产五个钢化玻璃
Glass[] temperGlasses = glassWorkShop.productGlass(
MaterialCenter.productMaterial(5,"沙子"),
MaterialCenter.productMaterial(6,"钢化玻璃材料"));
//新建一个镜子车间
MirrorWorkShop mirrorWorkShop = new MirrorWorkShop("镜子车间");
//使用镜框和普通玻璃生产镜子
Mirror[] mirrors1 = mirrorWorkShop.productMirrors(temperGlasses, frames1);
Mirror[] mirrors2 = mirrorWorkShop.productMirrors(glasses, frames2);
//新建两个销售部，销售一部和销售二部
SalesDepartment salesDepartment1 = new SalesDepartment("销售一部");
SalesDepartment salesDepartment2 = new SalesDepartment("销售二部");
//命令销售一部卖第一批镜子
salesDepartment1.saleMirrors(mirrors1);
//命令销售二部卖第二批镜子
salesDepartment2.saleMirrors(mirrors2);
}
}
结果：
带着【方形边框】的钢化玻璃镜子！被【销售一部】销售了！
带着【方形边框】的钢化玻璃镜子！被【销售一部】销售了！
带着【方形边框】的钢化玻璃镜子！被【销售一部】销售了！
带着【方形边框】的钢化玻璃镜子！被【销售一部】销售了！
带着【方形边框】的钢化玻璃镜子！被【销售一部】销售了！
镜子被销售一空
------------------------------------------
带着【圆形边框】的普通玻璃镜子！被【销售二部】销售了！
带着【圆形边框】的普通玻璃镜子！被【销售二部】销售了！
带着【圆形边框】的普通玻璃镜子！被【销售二部】销售了！
带着【圆形边框】的普通玻璃镜子！被【销售二部】销售了！
带着【圆形边框】的普通玻璃镜子！被【销售二部】销售了！
镜子被销售一空
------------------------------------------
网友评论