黑马程序员--java基础复习之面向对象
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
以前在学校的时候，学C语言基础的时候还没有接触到这个概念。直到由C转到学习C#的时候，才第一次接触它。但那时候理解得还是不清楚，迷迷糊糊的，后来在工作中，也一直没放在心上。直到这段时间学习java 基础的时候，才算真正理解了这个概念，也发现以前的工作中其实也用到了对象，只是自己一直没有真正理解这个概念，所以不认得它而已。
原来前几天一直写的if、for 、while语句等都是面向过程的，毕老师的视频里很形象的将面向过程比喻成将大象装冰箱这个笑话。将大象将冰箱分三步，将冰箱门打开，将大象装进去，将冰箱门关上。这是三个过程，在这个里，我们看到的是这三个动作。而面向对象则是将这三个功能都赋给冰箱这个对象，这样，我们看到的就不再这三个动作，而是冰箱。我们只需要调用冰箱的功能，同样能实现将大象装冰箱。与我们直接接触的是冰箱了，冰箱就是这个对象。
用我自己的理解来举例说明。我饿了，要吃饭，于是，我去菜场买菜，然后回来洗菜，切菜，煮饭，炒菜，然后才能吃饭。吃完饭还要善后：刷盘子洗碗。 一通下来，人也累得不行。这个就是面向过程。我们向对一大堆功能：买菜、洗菜、切菜、煮饭、炒菜，吃饭、善后。
现在我觉得自己做饭太累了，我出去吃，我去找个餐馆。“服务员，点菜”，点了盘宫爆鸡丁，一会儿菜上来了，上饭，开吃，吃完了一抹嘴，结账，走人。。。。这个就是面向对象。对象就是餐馆，我先是调用餐馆的点菜功能，将参数="宫爆鸡丁"传进去，然后餐馆这个对象就调用内部的买菜，洗菜、切菜，炒菜功能，这些功能我们一般都是看不到了，这个就是私有。最后菜好了，服务员把我要的菜返回给我。我吃完结账走人，然后善后功能都交给了对象。在这个过程中，我只需要找到这个对象（餐馆），使用这个对象的点菜功能，然后就开吃，最后再调用对象的结账功能。
很轻松的就吃了顿饭，从面向过程：买菜，洗菜，切菜，炒菜，煮饭，善后，一大堆功能都得自己执行。到面向对象：找个餐馆对象，然后调用对象的点菜，结账功能，就可以了。
面向对象的概念：
面向对象是相对面向过程而言的
面向对象和面向过程都是一种思想。
面向过程强调的是功能
面向对象则是将功能封装进对象，强调的是具备了功能的对象。
面向对象的好处：将复杂的事情简单化,从以前的执行者，过渡到现在的指挥者
面向对象三个特征：封装、继承、多态
在java的开发过程中，其实就是不断的创建对象，使用对象，指挥对象，以及维护对象之间的关系。
类和对象的关系
类就是对现实生活中事物的描述。
对象：就是这类事物实实在在存在的个体。
如
/*
需求：描述汽车(颜色，轮胎数)。描述事物其实就是在描述事物的属性和行为
而属性对应的就是类中的变量，行为对应的是类中的函数(方法)
*/
//其实定义类，就是在描述事物，就是在定义属性和行为。
//属性和行为共同成为类中的成员(成员变量、成员函数)
class Car
{
//描述颜色
String color="red";
//描述轮胎数
int num=4;
//描述行为
void run()
{
System.out.pritnln("Car run:"+color+".."+num);
}
}class CarDemo
{
public static void main(String[] args)
{
//生产汽车。在java中通过new操作符来完成。
//其实就是在堆内在中产生一个实体
Car c=new Car(); //c就是一个类类型的变量。类类型变量指向对象
//需求：将已有车的颜色改成蓝色。指挥该对象做使用
//在java中指挥的方式是：对象.对象成员
c.color="blue";
}
}在内存中是这样的
其实定义类，就是在描述事物，就是在定义属性和行为。
属性和行为共同成为类中的成员(成员变量、成员函数)
属性：对应类中的成员变量
行为：对应类中的成员函数
而对象则是事物的实实在在的个体
成员变量和局部变量
作用范围：
成员变量作用于整个类中，局部变量作用于函数中或语句中
存储位置：
成员变量在堆内存中。因为对象的存在，才在内存中存在。
局部变量存在于栈内存中.
初始值：
局部变量没有默认初始化值，而成员变量有默认初始化值
匿名对象
匿名对象是对象的简化形式。
使用方式一：当对对象的方法只调用一次时，可以使用匿名对象来完成，这样写比较简化,如果对对象的多个成员进行调用的时候，必须给给这个对象起一个名字
使用方式二：可以将匿名对象作为实际参数进行传递。
如:
new Car().run()
class CarDemo
{
public static void main(String[] args)
{
show(new Car());
}
public static void show(Car c)
{
c.num=6;
c.color="black";
c.run();
}
}封装(Encapsulation)
封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
好处：1、将变化隔离 2、便于使用 3、提高重用性 4、提高安全性
封装原则：
A、将不需要对外提供的内容都隐藏起来
B、把属性都隐藏，提供公共方法对其访问
注：函数就是程序中最小的封装体
封装的表现形式之一：private 私有
private ：私有，权限修饰符：用于修饰类中的成员(成员变量、成员函数)
注：私有只在本类中有效
如：
//定义一个Person类
class Person
{
//定义一个私有的成员变量
private int age;
//成员函数
void speak()
{
System.out.println("age="+age);
}
}
class PersonDemo
{
public static void main(String[] args)
{
//创建Person的一个对象
Person p=new Person();
//调用对象的私有成员变量，这里是编译失败的
p.age=-20;
p.speak();
}
}结果：
如上，将age私有化以后，类以外即使建立了对象也不能直接访问。但是人应该有年龄，就需要在Person类中提供对应访问age的方式。如下:
/定义一个Person类
class Person
{
//定义一个私有的成员变量
private int age;
public void setAge(int a)
{
age=a;
}
public int getAge()
{
return age;
}
//成员函数
void speak()
{
System.out.println("age="+age);
}
}
class PersonDemo
{
public static void main(String[] args)
{
//创建Person的一个对象
Person p=new Person();
//调用对象的私有成员变量，这里是编译失败的
//p.age=-20;
p.setAge(20);
p.speak();
}
}
之所以对外提供访问方式，就因为可以在访问方式中加入逻辑判断等语句，对访问的数据进行操作，提高代码健壮性。
如：
public void setAge(int a)
{
if(a>0&&a<130)
{
age=a;
speak();
}
else
System.out.println("年龄不合法");
}构造函数
构造函数特点：
A、函数名与类名相同
B、不用定义返回值类型
C、不可以写return语句
作用：给对象进行初始化
注意：
1、默认构造函数的特点。
2、多个构造函数是以重载的形式存在的
如：
class Person
{
//定义一个构造函数
Person()
{
System.out.println("我是构造函数");
}
}
class PersonDemo
{
public static void main(String[] args)
{
Person p=new Person();
}
}运行结果：
上述结果说明，对象一建立就会调用与之对应的构造函数。
构造函数的作用：可以用于给对象进行初始化
构造函数的小细节：
当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。
其格式如下:Person(){}; 而当类中自定义了构造函数后，默认的构造函数就没有了。
构造函数和一般函数在写法上的区别：
运行：构造函数是在对象一建立就运行，给对象初始化。而一般方法是对象调用才执行，是给对象添加对象具备的功能。
一个对象建立，构造函数只运行一次，而一般方法可以被该对象调用多次。
什么时候定义构造函数？
当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。
构造代码块
格式：
{
//执行语句;
}作用：给对象进行初始化 。
对象一建立就运行，而且优先于构造函数执行。
构造代码块和构造函数的区别：
构造代码块是给所有的对象进行统一初始化，而构造函数是给对应的对象初始化.
构造代码块中定义的是不同对象共性的初始化内容。
this关键字
this代表什么？
this 代表本类的对象
this 代表它所在函数所属对象的引用
通俗地说，哪个对象在调用this所在的函数，this就代表哪个对象
this 的应用：当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来
表示这个对象。但凡本类功能内部使用了本类对象，都用this表示
如下代码：
class Person
{
private String name;
private int age;
Person(int age)
{
this.age=age;
}
Person(String name,int age)
{
this.age=age;//this(age)，即调用上面那个构造函数 即new Person(age);
this.name=name;
}
}
class PersonDemo1
{
public static void main(String[] args)
{
Person p1=new Person(20);
Person p2=new Person(25);
}
}从上述代码中可以看出，this代表本类的对象，代表了它所在函数所属对象的引用，通俗地说，哪个对象在调用this所在的
函数，this就代表哪个对象
对this的概括总结：
this的两种用法：1、用于区分同名变量的情况，成员和局部同名的时候；
2、用于构造函数间调用。
注：一般函数不能直接调用构造函数，因为this语句不能用在一般函数中，只能用在构造函数间。
如：
class Person
{
private String name;
private int age;
Person(int age)
{
this.age=age;
}
Person(String name,int age)
{
this(age);//即调用上面那个构造函数 即new Person(age);
this.name=name;
}
}static关键字（静态）
用法：是一个修饰符，用于修饰成员(成员变量、成员函数)
当成员被静态修饰后，就多了一种调用方式，除了可以被对象调用外，还可以被类名.静态成员
被修饰后的成员具备以下特点：
A、随着类的加载而加载
也就是说：静态会随着类的消失而消失。说明它的生命周期最长。
B、优先于对象存在
明确一点：静态是先存在的，对象是后存在的
C、被所有对象所共享
D、可以直接被类名调用
代码：
class Person
{
String name;//成员变量，实例变量
static String country="CN";//静态的成员变量，类变量
public void show()
{
System.out.println(name+"::"+country);
}
}
class StaticDemo
{
public static void main(String[] args)
{
System.out.println(Person.country);
}
}
其中，类中的非静态变量称为实例变量（即对象的变量，随着对象而存在），而静态变量称为类变量(随着类的加载而加载)
实例变量和类变量的区别：
1、存放位置
类变量随着类的加载而存在于方法区中
实例变量随着对象的建立而存在于堆内在中
2、生命周期
类变量生命周期最长，随着类的消失而消失
实例变量生命周期随着对象的消失而消息。
静态的使用注意事项：
代码如下：
class Person
{
String name;//成员变量，实例变量
static String country="CN";//静态的成员变量，类变量
public static void show()
{
System.out.println(name+"::"+country);
}
}
class StaticDemo
{
public static void main(String[] args)
{
System.out.println(Person.country);
}
}
从上述代码中可以得出：
1、静态方法只能访问静态成员 上述代码中，在主函数中调用Person中的静态方法show（）,但是show()
方法访问了非静态成员name，所以报错。
而非静态方法既可以访问静态也可以访问非静态
2、静态方法中不可以定义this,super关键字
因为静态优先于对象存在。所以静态方法中不可以出现this （this代表对象）
3、主函数是静态的
静态的利弊
利：A、对对象的共享数据进行单独空间的存储，节省空间。
没有必要每个对象中都存储一份。
B、可以直接被类名调用。
弊：A、生命周期过长
B、访问出现局限性。(静态只能访问静态)
主函数
主函数：是一个特殊的函数。作为程序的入口，可以被jvm调用。
public static void main(String[] args)
主函数的定义
public:代表着该函数访问权限是最大的
static:代表主函数随着类的加载就已经存在了
void:主函数没有具体的返回值
main:不是关键字，但是是一个特殊的单词，可以被jvm识别
(String[] args):主函数的参数，参数类型是一个数组，该数组中的元素是
字符串。即字符串类型的数组
主函数是固定格式的，以便虚拟机识别
主函数的重载，如下：
class MainDemo
{
public static void main(String[] args)
{
System.out.println("A");
main(1);
}
//主函数的重载
public static void main(int x)
{
System.out.println("B");
}
}jvm调用主函数时传递了一个String类型的数组过来，那么，这个参数的内容是什么呢？如下：
class MainDemo
{
public static void main(String[] args)
{
System.out.println(args.length);
System.out.println(args);
}
}结果：
参数是一个长度为0的String类型的数组。
当我们手动传递参数时：
class MainDemo
{
public static void main(String[] args)
{
System.out.println(args.length);
for(int i=0;i
什么时候定义静态变量(类变量)呢？
当对象中出现共享数据时，该数据被静态所修饰。
对象中的特有数据要定义成非静态存在于堆内存中。
什么时候定义静态函数？
当功能内部没有访问到非静态数据(对象的特有数据)时，那么该功能可以定义成静态的。
静态代码块
格式：
static
{
//静态代码块中的执行语句
}
特点：随着类的加载而执行，只执行一次。
用于给类进行初始化。
例子：
class StaticCode
{
//静态代码块
static
{
System.out.println("a");
}
}
class StaticCodeDemo
{
//静态代码块
static
{
System.out.println("b");
}
public static void main(String[] args)
{
new StaticCode();
new StaticCode(); //类初始化后只执行一次
System.out.println("over");
}
//静态代码块
static
{
System.out.println("c");
}
}执行结果 b c a over
注：
Person p=new Person("zhangsan",20);
该句话做了什么事情？
1、因为new用到了 Person.class。所以会先找到Person.class文件并加载到内存中。
2、执行该类中的static代码块，如是有的话，给Person.class类进行初始化。
3、在堆内存中开辟空间，分配内存地址。
4、在堆内存中建立对象的特有属性，并进行默认初始化
5、对属性进行显示初始化(赋值)
6、对对象进行构造代码块初始化。
7、对对象进行对应的构造函数初始化
8、将内存地址赋给栈内存中的p变量
设计模式
设计模式：解决某一类问题最行之有效的方法
java中有23种设计模式
下面说下单例设计模式
单例设计模式：解决一个类在内存中只存在一个对象
想要保证对象唯一，有三步
1、为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象。
2、还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。
3、为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。
这三步怎么用代码实现呢？
1、将构造函数私有化。
2、在类中创建一个本类对象
3、提供一个方法可以获取到该类对象
单例设计模式有两种方式
一，饿汉式 特点是先初始化对象。在实际开发中，出于安全考虑，建议使用饿汉式，其具体代码如下：
class Single
{
private Single(){};//将构造函数私有化，这样，在其他类中就不能创建该类的对象
private static Single s=new Single();//在本类中自定义一个对象
//提供一个方法可以获取到该类对象
public static Single getInstance()
{
return s;
}
}在代码中，Single类进内存，对象还没有存在，只有调用了getInstance方法时，才创建对象。代码如下：
/*懒汉式*/
//对象是方法被调用时，才初始化，也叫做对象的延时加载。称为：懒汉式
//Single 类进内存时，对象还没有存在，只有调用了getInstance方法时，才建议对象。
class Single1
{
private Single1(){};
private static Single1 s=null;
public static Single1 getInstance()
{
if(s==null)
s=new Single1();
return s;
}
}