黑马程序员 Java基础<一>---> 面向对象与类之概述（匿名对象、封装、构造函数、this、静态等）

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

第一节 概述
一、面向对象的概述：

java是一种面向对象的编程语言，也就是说对象是这种语言的基础，没有对象了，就没有了java。任何功能都是通过对象来实现的，就是将功能封装进对象，让对象去调用这些功能。这种思想是将数据作为第一位，而方法（功能或者说是算法）作为其次。我个人认为，这是对数据的一种优化，安全性更高，操作起数据来一更方便。

那么将这种思想提升到一种境界就是：万物皆对象。

1、对面向对象的理解：

1）面向对象是相对面向过程而言的，且基于面向过程的。

2）面向对象是一种思想。

3）面向对象将功能封装进对象中，强调了具备功能的对象，主体是对象，将过程简化

4）在实际开发中，以对象为核心，先明确好对象，在实现具体功能，或者可是使用已有的对象。

5）面向对象的三个特征：封装性，继承性，多态性。

2、举例说明：

人是一个对象，人有吃饭，睡觉以及学习等等的行为（可称为功能），那么就是将吃饭、睡觉以及学习等功能封装进人这个的事物中，让人去执行这些功能，是人在调用这些方法，从而简化了过程。

第二节 类与对象

一、类与对象概述

1、类（class）：可以理解为是构造对象的一个蓝图或者模板，是抽象的概念；反过来说，对象是以类为模型创造的具体实例，是对类的一种具体化、形象化。

类：对生活中事物的描述

对象：对类的具体实现，是实实在在存在的实体。

2、例如：汽车的设计

类：指的是汽车的设计图纸

对象：指实际生产出来的汽车。

示例：

/**
需求|：定义一个汽车类，要求设计出汽车的型号（即名字），颜色，轮胎个数，行驶速度，并且让汽车行驶起来（即打印出每个汽车的颜色、轮胎数、速度）
并比较两辆汽车之间那个性能更好|：即速度快慢
思路|：
1创建一个构造函数，即一个汽车类，对其的颜色，轮胎数。行书速度，速度，以及其方法，即行驶等进行初始化
2在main方法中创建一个汽车对象，并实现其功能
3构造一个方法，比较两辆车之间的速度大小
*/class Car
{
String name;
String color;
int nums;
double speed;
Car(String name,String color,int nums,double speed)
{
this.name = name;
this.color = color;
nums = 4;
this.speed = speed;
System.out.println(name + "是一辆" + color + "，轮胎数是：" + nums + "，可以行驶的速度是：" + speed);
}

public void compare(Car c)
{
if(this.speed > c.speed)
{
System.out.println(this.name + "行驶得更快。");
return;
}
System.out.println(c.name + "行驶得更快。");
return;
}
}

class CarDemo
{
public static void main(String[] args)
{
Car a = new Car("奔驰","黑色的",4,500);
Car b = new Car("宝马","蓝色的",4,600);
a.compare(b);
}
}

二、成员变量与局部变量：

在类中的不同位置定义变量，作用范围是不同的，下面简单区分一下，两种变量的不同：

1）作用范围：

a.成员变量：作用于整个类中

b.局部变量：作用于函数中，或者作用于语句块中。

2）在内存中的位置：

a.成员变量：在堆内存中，因为对象的存在才在内存中存在。

b.局部变量：在栈内存中，随着函数的结束而消亡

3）初始化方式：

a.成员变量：随着类的初始化而初始化，在堆内存中被加载，有默认值，可直接参与运算

b.局部变量：随着方法的加载而加载进栈内存中，无初始化值，必须被初始化才能参与运算

上面汽车的例子中，a、b和c是局部变量，定义在了方法中，存在于栈内存中；而name、color、nums和speed都是成员变量，存在于堆内存中，随着类的加载而加载。

三、匿名对象

1、简述：所谓匿名对象，就是创建的对象没有名字，直接使用。

2、使用方式：

1）使用方式一：当对对象的方法只调用一次时，可以使用匿名对象来完成，这样写比较简化。

如果对一个对象进行多个成员调用，必须给这个对象起个名字

2）使用方式二：可以讲匿名对象作为实际参数进行传递，从而可以不用在main方法中创建一个变量，提高了编程效率，减少了代码书写。

但是这个对象实体在方法结束后，垃圾回收机制会将其作为垃圾回收。而非匿名对象则不同，当不使用了，会在某一时刻被回收，或是随着主函数的结束而被回收。

第二节 封装
一、概述

1、定义：封装是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

2、好处：

a.将变化隔离

b.便于使用

c.提高重用性

d.提高安全性

3、原则：

a.将不需要对外提供的内容隐藏起来

b.把属性都隐藏，提供公共方法对其访问

4、说明：

a.私有仅仅是封装的一种表现形式，如包也是一种封装形式

b.之所以对外提供访问方式，就是因为可以在访问方式中加入逻辑判断等语句，对访问的数据进行操作，提高了代码的健壮性。

二、private 关键字

1、private是一个权限修饰符

2、用于修饰成员（成员变量和成员函数）

3、被私有化的成员只在本类中有效。

4、常用之一：将成员变量私有化，对外提供对应的set和get 方法对其进行访问，提高了对数据访问的安全性。

5、当把类中的所有构造函数私有化后，代表着该类是不能创建对象的，因为对象不能进行初始化操作的。

示例：

/**需求：定义一个private变量，并定义两个方法，一个返回其值，另一个提供新值位于60-100之间的数给变量
思路：定义一个类，其属性包括一个变量，以及包括两个方法
一个方法返回变量的值，另一个方法提供60-100之间的值给变量
*/

class Virus
{
private int newSeconds = 0;
public int getSeconds()
{
return newSeconds;
}

public void setSeconds(int x)
{
if(x>60 || x<100)
{
newSeconds = x;
}
}
}

class VirusText
{
public static void main(String [] args)
{
Virus a = new Virus();
a.setSeconds(78);
System.out.println(a.getSeconds());
}
}

三、成员访问权限比较

权限大小

成员修饰符 public protected default(默认) private

同一个类中 OK OK OK OK

同一个包中 OK OK OK NO

子类访问 OK OK NO NO

不同包中 OK NO NO NO

四、public类与源文件名

一个编译单元（个人理解为执行main函数所调用到的所有文件）中只能有一个public类，且这个类的文件名必须要和其类名相同，包括大小写也必须一样。

原因：

1、一个编译单元只能有一个public类的原因：

第一、public的意思是所有类都能访问，包括包以外的类。public是作为这个编译单元的公开接口存在的。

第二、java程序的入口是main方法，所以被定为public的这个类一定是main方法的类，且这个类的名称要和文件名一直，因为虚拟机是要开始找main方法这个入口的。

第三、你可以根据需要，添加任意辅助功能的public权限的类，但是如果这个编译单元（注意是编译单元）里面有两个或以上public类的话，那么编译器就会报错。

建议：

第一、不要在一个源文件中写多个类。在标准的java代码编写时，无论代码量是多少，最好一个源文件只有一个类或接口（即使是接口也要如此），因为java是面向对象的语言，每个类都是抽象的结果，所以每个类要单独写在一个源文件里。

第二、只要要有一个是public类，虽然可以在编译单元中没有public类，即没有公开的接口，可在同一个包中访问，但是这样就将这个包都封闭了，是没意义的。如果没public，就可以随意给文件起名，可以不和类名相同。

2、被public修饰的类与文件名必须同名的原因：

第一、java是被编译执行的，它在运行时并不是将你写的所有类都先加载一遍的，而是当遇到import或使用到了其他类的时候，才会去在文件目录中找相应的class文件的。

第二、对于一个public类。上面也说了，是可以被项目中的任何一个类引用的，只需通过import导入即可。既然是作为虚拟机入口的main函数要用public修饰而成为一个公共接口，那么将类名和文件名一一对应就可以方便虚拟机在相应的路径（包名）中找到相关的信息；但是你如果不这么做，虚拟机很难去找，开销也会跟着增大的。

简单总结：

public作为一个公共接口（此接口非interface这个接口），修饰作为虚拟机入口的main函数，就是为了方便虚拟机找到相应的类，从而节省开销。

第三节 对象与函数

一、main函数：

我们刚开始接触java的时候就是用到了main函数，那么主函数是什么呢？在此分别对主函数的各个关键字及修饰符进行简单说明：

public static void main(String [] args){....}

1、主函数：是一个特殊的函数，作为程序的入口，可以被JVM识别并调用，它的格式是固定的。

2、主函数的定义：

1）public ：代表着该函数的访问权限是最大的。

2）static ：代表着主函数随着类的加载就已经存在了，一边执行函数中的代码。

3）void ：主函数没有具体的返回值，只是作为执行程序的入口。

4）main ：不是关键字，和其他的函数名类似，只不过别定义为一个特殊的单词，可以被JVM识别。

(String [] args))：函数的参数，参数类型是一个String类数组，元素为字符串。字符串类类型是数组，args是一个变量名，是约定俗成的，早期被写成arguments；如果改写成其他名称也是可以的。

3、注意：

可以重载主函数，但是虚拟机只识别固定格式的主函数，即 public static void main(String [] args){....}。

二、构造函数

先看一个简单的小程序

//创建一个简单的雇员类
public class Employee
{
//构造Employee函数
public Employee(String name,int age,double salary)
{
//将变量定义为private
private this.name = name;
private this.age = age;
private this.salary = salary;
}

{
System.out.println("我来工作了");
}

//访问器方法，获取name
public String getName()
{
return name;
}
//获取age
public int getAge()
{
//限制age的值
if (age<18)
{
System.out.println("不好意思啦，我们不接收未成年人！嘿嘿");
return;
}
return age;
}
//获取salary
public double getSalary()
{
return salary;
}
//修改雇员工资：涨byPercent个百分点的工资
public void setSalary(double salary,double byPercent)
{
salary + = salary*byPercent/100;
}
}

其中的public Employee(String name,int age,double salary)就是对这个类Employee的构造函数

1、特点：

a.函数名与类名相同

b.不用定义返回类型，括号中的参数可以没有，也可以有多个。

c.不可以写return语句

d.构造函数总是伴随着new操作一起被调用。

e.细节：当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数，即：类名(){}。但当类中自定义了构造函数后，默认的构造函数就不存在了。也就是说，每一个类中一定含有一个构造函数。

2、作用：给对象进行初始化

3、注意：

a.默认构造函数的特点

b.多个构造函数时以重载形式存在的。

3、构造函数与一般函数的区别：运行上不同

构造函数时在对象一建立就运行，是给对象初始化的。且一个对象建立后，构造函数只运行一次。

一般函数时对象调用才执行，是给对象添加对象具备的功能的。一般函数可以被该对象多次调用。

注：

一般函数是不能调用构造函数的，因为一般函数中不能定义this，而构造函数中可能存在this。

4、何时定义构造函数：

当分析事物时，该事物存在具备一些特性或行为，那么将这些内容定义在构造函数中。也就是说，一类事物一出现就应该存在的特性，这就需要构造函数对其进行初始化。

5、构造代码块：

如上面的小程序，其中打印的“我来工作了”这个语句块就是构造代码块。它和构造函数作用类似，只不过仅用一对花括号括起来即可。

1）作用：给对象进行初始化，对象一建立就运行，且优于构造函数执行，即在构造函数前加载。

2）与构造函数区别：

构造代码块是给所有对象进行统一初始化，是所有对象的共性初始化方式内容。如任何孩子出生都要哭几声。

构造函数是给对应的对象初始化，不同的对象有各自的特性，需要选择不同的构造函数初始化。

<<<<<------------------------------------------------------------------------------------------------------------------->>>>>

补充：

this关键字：

1、this：表面上，是用于区分局部变量和成员变量同名的情况。即this代表着当前对象的引用。

2、this的用法：

a.用于区分同名变量的情况。当局部已经定义了变量，当需要找成员中的变量，且变量名相同时，为了区分局部变量和成员变量的相同变量名，可以使用this加以区分。

b.用于构造函数间的调用。

3、特点：

1）this代表了本类的对象，即代表了它所在函数所属对象的引用，也就是说，哪个对象调用这个函数，this就代表哪个对象。

2）一般情况下，this都是被省略的，需要使用的时候才需加上。

如上面构造函数中的this的使用。

4、this应用：

当定义类中的功能时，该函数内部要用到调用该函数的对象时，这时用this来表示调用这个函数的对象。

只要本类功能内部使用了本类对象，都用this表示。

5、在构造函数中的应用：

this语句：用于构造函数之间的互相引用。且只能放在构造函数的第一行，否则编译失败。

原因：初始化的动作要先执行，因为自身的特性要先具备；如果初始化中还有初始化，要限制性更细节的操作，然后再执行自己所需求的初始化。

注意：不允许两个构造函数间相互调用this语句，否则会出现死循环。

一般函数中不能定义this语句。

<<<<<------------------------------------------------------------------------------------------------------------------->>>>>

三、static之静态函数

我们在学习java的最初就接触到了static这个修饰main方法的修饰符，那么static在java中有什么特点和作用呢？下面是对static的总结的几点：

一）总体来说static有这么几个特点：

1、随着类的加载而加载，在类中生命周期最长

2、优先于对象而存在

3、可以被所有对象共享

4、可以直接被类名调用

二）static的用法：
1、修饰成员：包括成员变量和成员方法

当成员被static修饰后，就多了一种调用方式，即可以被对象和类名调用

需要注意的一点：static绝对不能修饰局部变量。为什么呢？

局部变量的作用域就是它所在的方法或代码块中，而static的变量刚是定义在类中方法体外，是作为整个类共同使用的，它从类加载开始就存在，而局部变量在它所在的方法或代码块结束后就要被回收的。所以是不能修饰局部变量的

1）静态常量：

例如：在Math类中定义了一个静态常量PI

public class Math
{
...
public static final double PI = 3.14159265358979323846;//final将PI设置为不可再定义的常量
...
}

如果省略了static，PI就变成了一个实例常量，那么，每一个Math对象就都有自己的一个PI拷贝了，这样的话，对内存也是一种占用。

2）静态变量

如果将变量定义为static，那么每个类中只有这样一个变量。例如：

class Student
{
private int id;
private static int nextId = 1;
//获取id的访问器
public int getId()
{
return id;
}
public void setId()
{
id = nextId;
nextId++;
}
}

每个学生都有自己的一个id号，但这个Student的所有对象都共享一个nextId，即使不存在对象，也仍存在nextId，因为它是属于类的，而不属于任何独立的对象，所以它是随着类的加载而加载的，随着类的消亡而消亡的。

3）静态方法：

静态方法是一种不向对象进行操作的方法。当方法被static修饰的时候，此方法是用类名.方法名的方式使用的，当然也可以用对象名.方法名，但是这样就会产生误解，会让别人以为这个方法是非静态的，这样就有些不合理了。但是静态方法有一点需要注意的是：静态方法只能访问静态成员，因此静态方法也就不能定义this和super等关键字了。

那么在什么时候用到静态方法呢？

第一、当一个方法不需要访问对象是，其中所需的参数都是通过显示参数提供的。比如说Math.sqrt(double n)

第二、一个方法只需要访问累的静态变量时，如Person.getCountry();

private static String country = "CN";//因为国家是共有的，共享
public static void getCountry()
{
return country;
}

3、静态的应用：

当每个应用程序都有共同之处，可将其封装，提高其复用性。

需要注意的是：

a.对象时用于封装数据的；

b.对数据的操作方法，若没用到方法中特有的数据，则无需创建对象而占用多余的内存。

4、静态代码块

特点：a.随着类的加载而执行，且优先于主函数；b.只执行一次，类再创建对象，则不再执行，已经存在于内存中。

格式：

static
{语句}

5、静态是用注意事项：

1）静态方法只能访问静态成员，非静态方法既能访问静态也可以访问非静态

2）静态方法中不可定义this，super等关键字，因为静态优先于对象存在，所以静态方法中不可以出现this

3）主函数是静态的。

6、静态有利有弊：

好处：对对象的共享数据惊醒单独空间的存储，节省空进。没必要每个对象中都要存储一份，可以直接被类名调用

弊端：生命周期过长。访问出现局限性，因为静态只能访问静态。

举例：

class Student
{
private static String country = "CN";//因为国家是共有的，共享
private int id;
private static int nextId = 1;
//静态代码块
static
{
System.out.println("Hello");
}
public static String getCountry()
{
return country;
}
public int getId()
{
return id;
}
public void setId()
{
id = nextId;
nextId++;//前一个人获取id后，然后一个人获取下一个id时就加1
}
}

class StudentText
{
public static void main(String [] args)
{
Student st1 = new Student();
st1.setId();
System.out.println("st1'country = " + Student.getCountry() + "; st1id = " + st1.getId());
Student st2 = new Student();
st2.setId();
System.out.println("st2'country = " + Student.getCountry() + "; st2id = " + st2.getId());
}
}

运行结果如下：



第四节 单例设计模式

在java中存在很多通用的设计模式，今天我简单总结一下单例设计模式：
解决问题：解决一个类在内存中只存在一个对象的问题（比如说一个软件中的配置文件）
一、如何保证对象的唯一性：
1、为避免建立过多的该类对象，应首先禁止其他应用程序创建该类对象。
2、为让其他应用程序访问到该对象，在本类中自定义一个对象，为避免直接访问该对象，要对其进行私有化。
3、提供访问方式，便于其他程序对自定义对象的访问，提供的访问方法是公有的。
对象保证是惟一的了，那么该如何具体实现呢？
二、使对象唯一性的步骤：
1、将构造函数私有化
2、在类中创建一个本类对象，并设置为私有的
3、提供一个公有的方法获取该对象，便于使用
三、单例设计模式的具体表现形式
具体代码如下：
1、饿汉式：先初始化对象，类一进内存就加载

//饿汉式
class Single
{
private Single(){}
private static Single s = new Single();
public static  Single getSingle()
{
return s;
}
}

class SingleText
{
public static void main(String [] args)
{
Single s1 = Single.getSingle();
Single s2 = Single.getSingle();
if (s1==s2)
System.out.println(true);
else
System.out.println(false);
}
}

2、懒汉式：类进内存，对象还没有存在，只有调用了getSingle方法时，才建立对象

//懒汉式
class Single
{
private Single(){}
private static Single s = null;
public static Single getSingle()
{
if (s==null)
s = new Single();
return s;
}
}

class SingleText
{
public static void main(String [] args)
{
Single s1 = Single.getSingle();
Single s2 = Single.getSingle();
if (s1==s2)
System.out.println(true);
else
System.out.println(false);
}
}

运行的结果是：true；这是因为s1和s2引用的是同一个对象，所以符合条件。

但是对于第二种懒汉式的单例设计模式，会出现一些小小的问题，当一个线程调用时，是没什么问题的，如果多个线程调用此种方式，那么就会出现问题。

class Single
{
private static Single s = null;
private Single(){}
public static Single getInstance()
{
if (s == null)
{
synchronized(Single.class)
{
if (s == null)
s = new Single();
}
}
return s;
}
}

比如说，当A调用时，当读到if(s1==null) 时，可能就停在这了，然后cpu再调用B，B也读到if(s1==null)这停下了，cpu再切换到A，接着创建一个对象，A就执行完了；之后B也向下执行，又创建一个对象；此时，对象就不唯一了，就破坏了对象的唯一性的初衷。那么解决方案是这样的：

这利用了锁的机制。synchronized是java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。这涉及到了多线程的问题。在这个例子中，比如说，当A调用时，当读到第二个if(s1==null)
时，可能就停在这了，然后cpu再调用B，B读到第一个if(s1==null)这停下了，因为加上synchronized后，A进去就相当于将其他的调用锁在外面的语句上了，要先执行完A，那么A执行完后，就已经创建了一个对象；当B再读到第二个if(s1==null)的时候不符合就直接结束了。如果再有其他C或D等调用的时候，就直接不符合第一个(s1==null)的条件，所以直接返回s。在这里，我们再来看看关于懒汉式的多线程问题：

上面的懒汉式的写法，是效率比较高的，先看看下面一段代码，比较一下，就会清晰很多：

class Single
{
private static Single s = null;
private Single(){}
public static synchronized Single getInstance()
{
if (s == null)
s = new Single();
return s;
}
}

在这两种方式中，含有双重判断（称为第一种，无双重判断的为第二种）的效率更高，为什呢？虽然第一种和第二种都要先判断一下，但是对于第一种，第一个线程执行完后，s不为null了，那么后面只需要判断s是否为null即可，而对于第二种，要先判断锁，锁里没有线程，再进入，然后再判断一下s是否为null，这样一来，就要判断两次，所以，效率会更低。所以，对于双重判断，是可以提高效率的。

问题是解决了，但是相比之下，还是第一种饿汉式的单例设计模式更好一些，是一种建议使用的方式。