面向对象（1）
面向对象是Java语言区别c语言的一个重要特点，也是学好Java必须掌握的重要部分。接下来我会根据视频教程，总结对Java面向对象的理解与应用，以及牵涉到的一些知识点。
一、理解面向对象
我们知道c语言是一门面向过程的语言，那么面向对象就是相对面向过程而言的。如把大象装进冰箱，c语言强调的是功能行为：打开冰箱——>把大象装进冰箱——>关闭冰箱。而Java面向对象的思想就是强调具有功能的对象：冰箱打开，冰箱存储，冰箱关闭。感觉上就是过程是你自己亲自在做，而面向对象却是你指挥着对象去做。面向对象和面向过程都是一种思想，就看自己怎么想了，面向对象是基于面向过程的。
面向对象的特点：
1. 是一种符合人们思考习惯的思想
2. 可以将复杂的事情简单化
3.将程序员从执行者转换成了指挥者
4. 完成需求时：
(1)先要去找具有所需的功能的对象来用。
(2) 如果该对象不存在，那么创建一个具有所需功能的对象。
(3) 这样简化开发并提高复用。
在Java的开发过程，其实就是不断的创建对象，使用对象，指挥对象做事情。设计的过程，其实就是在管理和维护对象之间的关系。
面向对象的三个特征：
封装（encapsulation） 继承（inheritance） 多态（polymorphism）
二、类与对象
1、类与对象的关系
类就是：对现实生活中事物的描述。
对象：就是这类事物，是实实在在存在的个体。
想要描述：提取对象中共性内容，对具体的抽象。
描述时：这些对象的共性有：……
例如描述两个人。这两个人的共性有:姓名，年龄，性别，国籍.
映射到Java中，描述就是class中定义的类。具体对象就是对应Java在堆内存中用new建立的实体。
演示：
可以理解为：
类就是图纸。
汽车就是堆内存中的对象。
1 /* 2 需求：描述汽车（颜色和轮胎数）;想要描述。就要抽取对象中共性内容，对具体的抽象。 3 描述事物其实就是在描述事物的属性（成员变量）和行为（函数或方法） 4 其实定义类：就是在定义类的属性属性和行为 5 */ 6 class Car 7 { 8 //定义属性 9 String color="红色"; 10 int num =4; 11 //定义行为 12 void run() 13 { 14 System.out.println(color+".."+num); 15 } 16 17 } 18 class CarDemo 19 { 20 public static void main(String[]args) 21 { 22 //生产汽车,在Java中通过new操作符来完成。 23 Car c=new Car();//c就是类类型变量。也叫句柄。记住：类类型变量指向对象。 24 //需求，将已有车的颜色改为蓝色。指挥该对象做使用。在Java中指挥方法是：对象.对象成员。 25 c.color="blue"; 26 c.run(); 27 // System.out.print(); 28 } 29 }
2、成员变量和局部变量
之前我们用到的基本都是局部变量，现在我们将会使用成员变量。其实它两都是变量，规范写法上也没什么区别，都是标识符，但是在作用范围和内存中分配不同。
区别：
成员变量：
(1)成员变量定义在类中，在整个类中都可以被访问。
(2) 成员变量随着对象的建立而建立，存在于对象所在的堆内存中。
(3) 成员变量有默认初始化值。
局部变量：
(1) 局部变量只定义在局部范围内，如：函数内，语句内等。
(2) 局部变量存在于栈内存中。
(3) 作用的范围结束，变量空间会自动释放。
(4) 局部变量没有默认初始化值。
3、匿名对象
匿名对象是对象的简化形式。
匿名对象两种使用情况
(1)当对对象方法仅进行一次调用的时。
(2)匿名对象可以作为实际参数进行传递。
例： new Car();
注：如果对一个对象进行多个成员调用，必须给这个对象起个名字。
三、对象的封装
1、 概念
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
2、 好处
(1)将变化隔离。
(2)便于使用。
(3)提高重用性。
(4)调高安全性。
3、 原则
(1) 将不需要对外提供的内容都隐藏起来。
(2) 把属性都隐藏，提供公共方法对其访问。
4、 封装的表现形式之一——private（私有）
private关键字：权限修饰符；用于修饰类中的成员（成员变量，成员函数）；私有只在本类中有效。
常用之一：
将成员变量私有化，对外提供对应的set，get方法对其进行访问。提高对数据访问的安全性。
如：我有一个人对象，而年龄这一属性我不想被对象访问，我就可以将其设为private。
人物对象程序：
1 /* 2 需求：定义人的对象，可以输入姓名和年龄。打印出这个人的年龄和姓名。并对年龄进行判定，如果不符合常理，就不对年龄进行赋值。 3 */ 4 class PersonDemo 5 { 6 public static void main(String[] args) 7 { 8 //符合常理 9 Person p=new Person("青衫",20); 10 //不符合常理 11 Person p1=new Person("彭祖",800); 12 } 13 } 14 class Person 15 { 16 //定义人的属性。private代表私有化，其他类中的程序不可以访问。 17 private String name; 18 private int age; 19 int speak; 20 //构造方法 21 Person(String name,int age) 22 { 23 //把年龄传入并进行判定 24 setAge(age); 25 //打印姓名和年龄 26 speak(name,getAge()); 27 28 } 29 //设置姓名 30 public void setName(String n) 31 { 32 name=n; 33 } 34 //获取姓名 35 public String getName() 36 { 37 return name; 38 } 39 //设置年龄 40 public void setAge(int a) 41 { 42 if(a>0&&a<130) 43 { 44 age = a; 45 46 } 47 else{ 48 System.out.println("非法age");} 49 } 50 //获取年龄 51 public int getAge() 52 { 53 return age; 54 } 55 //调用说话功能 56 public void speak(String n,int a) 57 { 58 59 name=n; 60 age=a; 61 System.out.println("姓名："+name+"\t年龄："+age ); 62 } 63 }
运行结果：
四、对象知识——构造函数
1、 特点：
(1) 函数名与类名相同。
(2) 不用定义返回值类型。
(3) 不可以写return语句。
2、 作用：
给对象进行初始化。
3、构造函数的小细节：
当一个类中没有定义构造函数时，那么系统就会默认给该类加入一个空参数的构造函数。当在类中自定义了构造函数后，默认的构造函数就没有了。
4、构造函数和一般函数在写法上有不同。
class Person
{
Person()
{
//构造函数
}
}
在运行上也有不同：
构造函数是在对象一建立就运行，给对象初始化。而一般方法是对象调用才执行，给对象添加对象具备的功能。一个对象建立，构造函数只运行一次。而一般方法可以被该对象调用多次。
5、什么时候定义构造函数？
当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。
6、构造代码块
格式：
class Person
{
{
// 构造代码块
}
}
作用：给对象进行初始化。对象一建立就运行，而且优先于构造函数运行。
和构造函数的区别：
构造代码块是给所有对象进行初始化。
而构造函数是给对应的对象初始化。
构造代码块中定义的是不同对象共性的初始化内容。
五、对象知识点——this关键字
this代表它所在函数所属对象的引用。
简单说：哪个对象在调用this所在的函数，this就代表哪个对象。
this的应用：
当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。
但凡本类功能内部使用到了本类对象，都用this表示。
this语句：
用于构造函数之间进行互相调用。如：this(name);
thi语句只能定义在构造函数的第一行。因为初始化要先执行。
对this的概括总结：
this的两种用法：
1、用于区分同名变量的情况，说的成员和局部同名的时候；
2、用于构造函数间调用。
注：一般函数不能直接调用构造函数，因为this语句不能用在一般函数中，只能用在构造函数间。
六、对象知识点——static（静态）关键字
用法：是一个修饰符，用于修饰成员（成员变量，成员函数）
当成员被静态修饰后，不仅可以被对象直接调用。还可以直接被类名调用。
方式：类名.静态成员。
静态特点：
1、 随着类的加载而加载，随着类的消失而消失。生命周期最长。
2、优先于对象存在。
3、被所有对象共享。
4、可以被类名直接调用。
实例变量（成员变量）和类变量（静态的成员变量）的区别。
1、存放位置
类变量随着类的加载而存在于方法区中。
实例变量随着对象的加载而存在于堆内存中。
2、生命周期:
类变量的生命周期最长。随着类的消失而消失。
实例变量生命周期随着对象的消失而消失。
静态使用注意事项：
1、静态方法只能访问静态成员。
非静态方法既可以访问静态，也可以访问非静态。
2、静态方法中不可以定义this，super关键字。
因为静态优先于对象存在，说以静态方法中不可以出现this。
3、主函数是静态的。
主函数是一个特殊的函数。作为程序的入口，可以被jvm调用。
主函数的定义：
public：代表着该函数访问权限的是最大的。
static：代表主函数随着类的加载就已经存在了。
void：主函数没有具体的返回值。
main：不是关键字，但是是一个特殊的单词，可以被jvm识别。
（String[]args）函数的参数，参数的类型是一个数组，该数组中的元素是字符串。
存储字符串类型元素的数组。
主函数是固定格式的：jvm识别。
Jvm在调用主函数是，传入的是new String[0];
静态有利有弊
利：对对象的共享数据进行单独空间的存储，节省空间，没有必要每一个对象中都存储一份。
可以直接被类名调用。
弊：生命周期过长。
访问出现局限性（静态随好，只能访问对象）
什么时候使用静态？
要从两方面下手：
静态修饰的内容有成员变量和函数。从这两方面。
什么时候定义静态变量（类变量）呢？
当对象中的出现共享数据时，该数据被静态所修饰。对象中的特有数据要定义成非静态。
什么时候定义静态函数呢？
当功能内部没有访问到非静态数据（对象的特有数据），那么该功能可以定义成静态的。
静态的应用
每一个应用程序中都有共性的功能。可以将这些功能抽取，独立封装。以便能复用。
虽然可以通过建立对象使用工具方法。但是如果该对象中没有封装特有数据。操作中的每一个方法也没有用到对象中的特有数据。这时就考虑，为力让程序更严谨。是不需要对象的。
可以将该工具类中的方法都定义成静态的。直接通过类名调用即可。为了防止创建对象。需要把构造函数私有化。
对象的初始化过程
Person p=new Person(“lisi”,20);
该句话都做了什么事情？
1、因为new用到了Person.class，所以会先找到Person.class文件并加载到内存中。
2、执行该类的静态代码块（如果有的话），给Person类进行初始化。
3、在堆内存中开辟空间，分配内存地址。
4、在堆内存中建立对象特有属性，并进行默认初始化。
5、对属性进行显示初始化。
6、对对象进行构造代码块初始化。
7、对对象进行对应的构造函数初始化。
8、把内存地址赋给栈内存中的p变量
静态的应用——文档说明书。
每一个应用程序中都有共性的功能，可以将这些功能进行抽取，独立封装。以便复用。
下面我们以一个数组工具类为例，作一个文档说明书。
程序：
1 /** 2 这是一个可以对数组进行相关操作的工具类，该类提供了取数组的最值、排序等功能。 3 @author 青衫 4 @version V1.1 5 6 */ 7 //类名权限要最大才能创建说明书文档 8 public class ArrayTool 9 { 10 /** 11 空参数构造函数 12 */ 13 private ArrayTool() //私有化构造函数是为了让其不能创建对象。 14 { 15 16 } 17 18 /** 19 这个功能用于得到int类型数组中的最大值 20 @param arr 接收一个int类型的数组 21 @return 返回接收的该数组的最大值 22 */ 23 public static int getMax(int[] arr) 24 { 25 int max=0; 26 for (int x=1;x<arr.length ;x++ ) 27 { 28 if(arr[x]>arr[max]) 29 max=x; 30 } 31 return arr[max]; 32 } 33 34 /** 35 这个功能用于得到int类型数组中的最小值 36 @param arr 接收一个int类型的数组 37 @return 返回该数组的最小值 38 */ 39 public static int getMin(int[] arr) 40 { 41 int min=0; 42 for (int x=1;x<arr.length ;x++ ) 43 { 44 if(arr[x]<arr[min]) 45 min=x; 46 } 47 return arr[min]; 48 } 49 50 /** 51 对int类型数组进行选择升序排列 52 @param arr 接收一个int类型的数组 53 */ 54 public static void selectSort(int[] arr) 55 { 56 for (int x=0;x<arr.length-1 ; x++) 57 { 58 for (int y=x+1; y<arr.length; y++) 59 { 60 if(arr[x]>arr[y]) 61 swap(arr,x,y); 62 } 63 } 64 } 65 66 /** 67 对int类型数组进行冒泡升序排列 68 @param arr 接收一个int 类型数组 69 */ 70 public static void bubbleSort(int[] arr) 71 { 72 for (int x=0;x<arr.length-1;x++ ) 73 { 74 for (int y=0;y<arr.length-x-1;y++ ) 75 { 76 if(arr[y]>arr[y+1]) 77 swap(arr,y,y+1); 78 } 79 } 80 } 81 82 /** 83 对数组中的两个元素进行位置交换 84 @param arr 接收一个int类型的数组 85 @param a 要置换的元素角标 86 @param b 要置换的元素角标 87 */ 88 private static void swap(int[] arr,int a,int b) 89 { 90 arr[a]=arr[b]+(arr[b]=arr[a])*0; 91 } 92 93 /** 94 遍历数组：打印数组中所有元素，形式为：[elemet1,elemet2,...] 95 @param arr 接收一个int类型的数组 96 */ 97 public static void printArray(int[] arr) 98 { 99 System.out.print("["); 100 for (int x=0; x<arr.length-1; x++) 101 { 102 System.out.print(arr[x]+", "); 103 } 104 System.out.println(arr[arr.length-1]+"]"); 105 } 106 }
在dos命令行中输入命令：javadoc -d myhelp -author-version ArrayTool.java
Java中的javadoc工具就会帮我们完成说明文档也称API的制作。
如图：
api的页面：
七、单例设计模式
解决一个类在内存中只存在一个对象。
想要保证对象唯一。
1、为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象
2、还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。
3、为了方便其他程序对自定义程序的访问，可以对外提供一些访问方式。
这三步怎么用代码体现？
1、将构造函数私有化。
2、在类中创建一个本类对象。
3、提供一个方法可以获取到该对象。
例：
1 class Single 2 3 { 4 5 private Single(){} 6 7 private static Single s=new Single(); 8 9 public static Single getInstance() 10 11 { 12 13 return s; 14 15 } 16 17 }
这个是先初始化对象。称为饿汉式。Single类一进内存，就已经创建好了对象。
class Single { private Single(){} private static Single s=null; public static Single getInstance() { If（s==null） { synchronized(Single.class) { If(s==null) s=new Single(); } } return s; } }
这个对象是方法被调用时，才初始化。也叫做对象的延时加载。称为懒汉式。
Single类进内存，对象还没有存在，只有在调用了getInstance方法时，才建立对象。
记住原则：定义单例。建议使用饿汉式。
我们在设计类时，对于事物该怎么描述还怎么描述，只有当需要将该事物的对象保证在内存中唯一时，就将以上三步加上即可。
浙公网安备 33010602011771号