本文详细解析Java的面向对象思想，包括类与对象的概念、成员变量与局部变量的区别、对象封装、构造函数、this关键字、静态概念及应用、静态代码块等核心知识点。同时介绍了静态变量和静态函数的使用场景，并通过一个数组工具类的实例展示了Java中的工具类设计，以及单例设计模式的两种实现方式：饿汉式和懒汉式。
------- android培训、java培训、期待与您交流！ ----------
面向对象
面向对象：是一种思想，想学好Java必须掌握面向对象。
c语言是一门面向过程的语言，c语言强调的是功能行为。
Java面向对象的思想就是强调具有功能的对象。面向对象是把行动者变成了指挥者。
1. 是一种符合人们思考习惯的思想
2. 可以将复杂的事情简单化
3.将程序员从执行者转换成了指挥者
Java的开发过程，其实就是不断的创建对象，使用对象，指挥对象做事情。
设计的过程，其实就是在管理和维护对象之间的关系。
类与对象
如图我们可以理解为：类是事物的描述，对象是实体（也可以理解为：类就是图纸，汽车就是对象。）
类：
使用计算机语言就是不断的描述现实生活中的事物，而java中描述事物通过类的形式体现。Java是用类class来描述对象的属性和行为，通过new创建对象，即是该类事物实实在在存在的个体。
如何用代码形式创建对象
描述小汽车
分析：
1，属性。
轮胎数。
颜色。
2，行为。
运行。
*/
class Car
{
int num;
String color;
void run()
{
//int num = 10;
System.out.println(num+"..."+color);
}
}
class CarDemo
{
public static void main(String[] args)
{
//在计算机中创建一个car的实例。通过new关键字。
Car c = new Car();// c就是一个类类型的引用变量，指向了该类的对象。
c.num = 4;
c.color = "red";
c.run();//要使用对象中的内容可以通过 对象.成员 的形式来完成调用。
}
}成员变量和局部变量
之前我们用到的基本都是局部变量，现在我们将会使用成员变量。其实它两都是变量，规范写法上也没啥区别，都是标识符，但是在作用范围和内存中分配不同。
匿名对象
匿名对象是对象的简化形式，匿名对象两种使用情况。
1、当对对象方法仅进行一次调用的时。
2、匿名对象可以作为实际参数进行传递。
匿名对象。没有名字的对象 。
new Car();//匿名对象。其实就是定义对象的简写格式。
Car c = new Car();
c.run();
new Car().run();
1，当对象对方法仅进行一次调用的时候，就可以简化成匿名对象。
new Car().num = 5;
new Car().color = "green";
new Car().run();//基本数据类型参数传递
class Demo
{
public static void main(String[] args)
{
int x = 3;
show(x);
System.out.println("x="+x);
}
public static void show(int x)
{
x = 4;
}
}
//引用数据类型参数传递
class Demo
{
int x = 3;
public static void main(String[] args)
{
Demo d = new Demo();
d.x = 9;
show(d);
System.out.println(d.x);
}
public static void show(Demo d)
{
d.x = 4;
}
}对象的封装
（私有）private关键字：权限修饰符，用于修饰类中的成员（成员变量，成员函数）。
私有只在本类中有效。
将成员变量私有化，对外提供对应的set，get方法对其进行访问。构造函数
构造函数小特点
当一个类中没有定义构造函数时，那么系统就会默认给该类加入一个空参数的构造函数。
当在类中自定义了构造函数后，默认的构造函数就没有了。
构造函数和一般函数区别构造函数是在对象一建立就运行，给对象初始化。
一个对象建立，构造函数只运行一次。
一般方法是对象调用才执行，给是对象添加对象具备的功能。
一般方法可以被该对象调用多次。
什么时候定义构造函数当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。
构造代码块和构造函数的区别：
构造代码块给对象进行初始化。对象一建立就运行。
构造代码块是给所以对象进行初始化。而构造函数是给对应的对象初始化。
构造代码块中定义的是对象共性的初始化内容。
this关键字
/*
当成员变量和局部变量重名，可以用关键字this来区分。
this : 代表对象。代表哪个对象呢？当前对象。
this就是所在函数所属对象的引用。
简单说：哪个对象调用了this所在的函数，this就代表哪个对象。
this也可以用于在构造函数中调用其他构造函数。
注意：只能定义在构造函数的第一行。因为初始化动作要先执行。
*/
class Person
{
private String name;
private int age;
Person()
{
name = "baby";
age = 1;
System.out.println("person run");
}
Person(String name)
{
this();
this.name = name;
}
Person(String name,int age)
{
this.name = name;
this.age = age;
}
public void speak()
{
System.out.println(this.name+":"+this.age);
}
}this的应用：
当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。
但凡本类功能内部使用到了本类对象，都用this表示。
this的两种用法
1、用于区分同名变量的情况，说的成员和局部同名的时候；
2、用于构造函数间调用。
static（静态）关键字
static的特点：
1，static是一个修饰符，用于修饰成员。
2，static修饰的成员被所有的对象所共享。
3，static优先于对象存在，因为static的成员随着类的加载就已经存在了。
4，static修饰的成员多了一种调用方式，就可以直接被类名所调用 。 类名.静态成员 。
5，static修饰的数据是共享数据，对象中的存储的是特有数据
当成员被静态修饰后，可以直接被类名调用。
格式：类名.静态成员
成员变量和静态变量的区别
1，两个变量的生命周期不同。
成员变量随着对象的创建而存在，随着对象的被回收而释放。
静态变量随着类的加载而存在，随着类的消失而消失。
2，调用方式不同。
成员变量只能被对象调用。
静态变量可以被对象调用，还可以被类名调用。
3，别名不同。
成员变量也称为实例变量。
静态变量称为类变量。
4，数据存储位置不同。
成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据.
静态变量数据存储在方法区(共享数据区)的静态区，所以也叫对象的共享数据.
静态使用的注意事项：
1，静态方法只能访问静态成员。(非静态既可以访问静态，又可以访问非静态)
2，静态方法中不可以使用this或者super关键字。
3，主函数是静态的。
什么时候用静态
1，静态变量。
当分析对象中所具备的成员变量的值都是相同的 。
这时这个成员就可以被静态修饰。
只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。
如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，定义成静态的。
2，静态函数。
函数是否用静态修饰，就参考一点，就是该函数功能是否有访问到对象中的特有数据。
简单点说，从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的。
如果不需要，就可以将该功能定义成静态的。当然，也可以定义成非静态，
但是非静态需要被对象调用，而仅创建对象调用非静态的
没有访问特有数据的方法，该对象的创建是没有意义。
格式：
static
{
静态代码块中的语句。
}
特点：随着类的加载而执行，执行一次。并优先于主函数。用于给类进行初始化。
对象的初始化过程：
1、把类名.class文件加载到内存中。
2、执行该类中的static代码块，如果有得话，给该类进行初始化。
3、在堆内存中开辟空间，分配内存地址。给对象
4、在堆内存中建立对象的特有属性。并进行默认初始化。
5、对属性进行显示初始化。
6、对对象进行构造代码块初始化。
7、对对象进行对应构造函数初始化。
8、将内存地址赋给栈内存中的对象名变量。
主函数的构造说明
java中的工具类
每一个应用程序中都有共性的功能，可以将这些功能进行抽取，独立封装。以便复用。下面我们以一个数组工具类为例，作一个文档说明书。
/**
建立一个用于操作数组的工具类，其中包含着常见的对数组操作的函数如：最值，排序等 。
@author 郭
@version
*/
public class ArrayTool
{
private ArrayTool(){}//该类中的方法都是静态的，所以该类是不需要的创建对象的。为了保证不让其他成创建该类对象
//可以将构造函数私有化。
/**
获取整型数组的最大值。
@param arr 接收一个元素为int类型的数组。
@return 该数组的最大的元素值
*/
public static int getMax(int[] arr)
{
int maxIndex = 0;
for(int x=1; x<arr.length; x++)
{
if(arr[x]>arr[maxIndex])
maxIndex = x;//
}
return arr[maxIndex];
}
/**
对数组进行选择排序。
@param arr 接收一个元素为int类型的数组。
*/
public static void selectSort(int[] arr)
{
for(int x=0; x<arr.length-1; x++)
{
for(int y=x+1; y<arr.length; y++)
{
if(arr[x]>arr[y])
swap(arr,x,y);
}
}
}
/*
用于给数组进行元素的位置置换。
@param arr 接收一个元素为int类型的数组。
@param a
@param b
*/
private static void swap(int[] arr,int a,int b)
{
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
/**
获取指定的元素在指定数组中的索引.
@param arr 接收一个元素为int类型的数组。
@param key 要找的元素。
@return 返回该元素第一次出现的位置，如果不存在返回-1.
*/
public static int getIndex(int[] arr,int key)
{
for(int x=0; x<arr.length; x++)
{
if(arr[x]==key)
return x;
}
return -1;
}
/**
将int数组转换成字符串。格式是：[e1,e2,...]
@param arr 接收一个元素为int类型的数组。
@return 返回该数组的字符串表现形式。
*/
public static String arrayToString(int[] arr)
{
String str = "[";
for(int x=0; x<arr.length; x++)
{
if(x!=arr.length-1)
str = str + arr[x]+", ";
else
str = str + arr[x]+"]";
}
return str;
}
}在dos命令行中输入命令：javadoc -d Myhelp -author-version ArrayTool.java
Java中的javadoc工具就会帮我们完成API的制作。
单例设计模式
设计模式的概念：解决某一问题最行之有效的方法。
单例设计模式的作用：使一个类在内存中只存在一个对象。
步骤：
1、将构造函数初始化。
2、在类中创建一个本类对象。
3、提供一个访问方法可以获取到该对象。
单例设计模式有两种写法（背也要背下来）
1、饿汉式：也就是刚三部中的示例语句。它的特点是先初始化对象。
如：Single类一进内存，就已经创建好了对象。在实际开发中，出于安全考虑，建议使用饿汉式。
class Single
{
private static Single sin=new Single（）； //直接创建对象，比较常用；
private Single（）{}//构造函数私有化，使其他类中不能创建该类对象。
public static Single getInstance（）//括号里面可以写入条件，从而实现可控性。
{
return sin；
}
} 2、懒汉式：它的特点对象是方法被调用时，才初始化，这也叫对象的延时加载。
如：在以下完整代码中，Single类进内存，对象还没有存在，只有调用了getInstance()方法时，才创建对象。
class Single
{
private static Single sin=null; //这里就是体现出懒汉，初始值定义为空，被调用时才创建对
private Single（）{}//构造函数私有化，使其他类中不能创建该类对象。
public static Single getInstance（) //括号里面可以写入条件，从而实现可控性。
{
if（sin==null）
sin=new Single（）；
return sin；
}
} 
扫一扫
876
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
