1、面向对象概念
1.1、理解面向对象
(1)面向对象是相对面向过程而言的。
(2)面向对象和面向过程都是一种思想。面向对象是将功能封装进对象,强调具备了功能的对象。面向过程强调的是功能行为。
(3)面向对象是基于面向过程的。
1.2、面向对象的特点
面向对象有三个特征:封闭、继承、多态。
2、类与对象的关系
(1)类就是对现实生活中事物的描述。
(2)对象就是这类事物实实在在存在的个体。
(3)在Java中,描述就是用class关键字定义的类,具体对象就是对应Java在堆内存中用new关键字建立的实体,描述事物其实就是在描述的属性和行为,属性对应类中的变量,行为对应类中的方法,定义类就是在定义事物的属性和行为,属性和行为共同成为类中的成员。
示例:
Class Car
{
String color; //描述颜色
void run(){} //描述行为
}
说明:定义了一个Car类,类中定义了color属性(成员变量)和run行为(成员方法)。
有了类,可用new关键字产生该类的一个实体:
Car c=new Car();
说明:c是一个Car一个实体对象,是一个类类型变量,而类类型变量指向对象。
产生对象后,可以使用对象访问对象的成员,访问格式为:对象名.对象成员,如c.color访问Car的color属性。
3、成员变量与局部变量
(1)成员变量作用于整个类中,且在内存中成员变量因为对象的存在才存在于堆内存中。
(2)局部变量作用于函数中或者语句中,存在栈内存中。
4、匿名对象
匿名对象是对象的简化形式。
匿名对象的使用方式:
(1)当对对象的方法只调用一次时,可以用匿名对象来完成,这样写比较简化,如果对一个对象进行多个成员调用,必须给这个对象起个名字。
(2)匿名对象可以将对象作为实际参数进行传递。
5、封装
封装是指隐藏对象的属性和实现细节,仅对外提供公共访问方式。
5.1、封装的好处
(1)将变化隔离
(2)便于使用
(3)提高重用性
(4)提高安全性
5.2、封装原则
(1)将不需要对外提供的内容都隐藏起来。
(2)把属性都隐藏起来,提供公共方法对其访问。
5.3、private
private表示私有。一种权限修饰符,用于修饰类中的成员(成员变量、成员函数),私有只在本类中有效。被private修饰的成员不可以被对象直接访问,如果私有成员需要在本类以外被访问,就需要在本类中提供访问该成员的方法。
示例:
class Person
{
private int age;
public void setAge(int a) //定义set方法对私有成员age进行修改
{
Age=a;
}
}
说明:声明了一个Person类,类中age属性被私有,并提供setAge方法对属性age进行操作,当通过Person p=new Person()声明一个对象p时,不能用p.age直接访问,只能通过p对象调用setAge方法访问age。
注意:封装不代表私有,私有仅仅是封装的一种表现形式。
5.4、构造函数
特点:函数名与类名相同,不用定义返回值类型,不可以写return语句。
作用:给对象进行初始化,因为对象一建立就会调用与之对应的构造函数。
注意:多个构造函数是以重载的形式存在的。当一个类中没有定义构造函数时,那么系统会默认给该类加入一个空参数的构造函数,这个默认的构造函数的权限与所属类一致辞。当在类中自定义了构造函数后,默认的构造函数就没有了。
格式:类名(参数列表){}
示例:
class Person
{
private String name;
Person(String n) //定义构造函数
{
name=n;
}
}
说明:声明了一个Person类,类中定义了一个成员变量name和一个构造函数Person(String n),此时若要建立一个Person类的实例对象,只能Person p=new Person(“n”),而不能Person p=new Person(),因为此时已没有默认的不带参数列表的构造函数。
构造函数与一般函数的区别:
(1)在写法上,构造函数与一般函数有不同。
(2)在运行上,构造函数在对象一建立时就运行,给对象初始化。而一般函数是需要对象调用才执行,是给对象添加对象具备的功能。
(3)一个对象建立,构造函数中运行一次,而一般方法可以被对象调用多次。
什么时候定义构造函数:
当分析事物时,该事物一存在就具备一些特性或行为,那么就可以将这些内容定义在构造函数中。
5.5、构造代码块
作用:给对象进行初始化。对象一建立就运行,而且优先于构造函数执行。
和构造函数的区别:构造代码块是给所有对象进行统一初始化,而构造函数是给对应的对象初始化。构造代码块中定义的是不同对象共性的初始化内容。
格式:{ 对象初始化语句 }。
示例:
class Person
{
private String name;
//定义构造代码块
{
System.out.println(“Peson code run”);
}
Person(String n)
{
name=n;
}
}
说明:在Person中定义了一个构造代码块,当用new建立一个对象时,程序首先会调用该构造代码块,即会打印Person code run。
5.6、this关键字
作用:当类中局部变量和成员同名时this用于区分局部变量和成员变量。this就代表本类的对象,代表它所在函数所属对象的引用,即哪个对象在调用this所在的函数,this就代表哪个对象。
格式:this.成员
示例:
class Person
{
private String name;
Person(String name)
{
This.name=name;
}
}
说明:在类Person中定义了私有成员变量name,定义了构造函数Person(String name),Person函数中有局部变量与成员变量name同名,此时为了区别构造函数中的局部变量和类中成员变量,在调用成员变量name时用this.name调用。
应用:当定义类中功能时,该函数内部要用到调用该函数的对象时,这时用this来表示这个对象。但凡本类功能内部使用到了本类对象,都用this表示。
示例:
class Person
{
private String name;
private int age;
Person(String name,int age)
{
this.name=name;
this.age=age;
}
public boolean compareAge(Person p)
{
retrun this.age==p.age;
}
}
说明:定义了一个类Person,类有定义了一个比较年龄的功能函数compareAge,当建立两个对象p1和p2,当用p1调用compareAge方法p1.compareAge(p2)时,this.age就代表p1对象的age,this就代表了p1。
this语句:只用于构造函数之间进行互相调用,因为一般函数不能直接调用构造函数。this语句只能是在构造函数中的第一个语句。因为初始化要先执行。
格式:this(函数元素,…)
示例:
class Person
{
private String name;
private int age;
Person(String name)
{
this.name=name;
}
Person(String name,int age)
{
this(name);//this语句相当于调用构造函数Person(name);
this.age=age;
}
}
说明:定义了一个类Person,类中定义了两个构造函数Person(String name)和Person(String name,int age),当在Person(String name,int age)要调用Person(String name)时,用this语句。
5.7、static关键字
static关键字也是一种修饰符,用于修饰成员(成员变量和成员函数)。
被修饰后的成员具备以下特点:
-随着类的加载而加载。
-优先于对象存在。
-被所有对象所共享。
-可以直接被类名调用。
注意:
-静态方法只能访问静态成员。非静态即可以访问静态也可以访问非静态。
-静态方法中不可以写this,super关键字,因为静态优先于对象存在。
-主函数是静态的。
示例:
class Person
{
private String name;
static String country=”CN”; //定义静态成员
Person(String name)
{
this.name=name;
}
}
说明:定义了一个类Person,类中定义了一个静态变量country,此时静态变量country会随着类的加载而加载,属于所有Person类对象的共享数据,且可以被类名直接调用,格式为:Person.country。
静态成员在内存中存储在方法区中,静态成员变量也被称为类变量,类变量与成员变量的区别:
(1)存放位置:类变量随着类的加载而存在于方法区中,成员变量随着对象的建立而存在于堆内存中。
(2)生命周期:类变量生命周期最长,随着类的消失而消失,成员变量生命周期随着对象的消失而消失。
静态的利弊:
利:对对象的共享数据进行单独空间的存储,节省空间,没有必要在每一个对象中都存储一份。可以直接被类名调用。
弊:生命周期过长。访问出现局限性(只能访问静态)。
什么时候定义静态变量:当对象中出现共享数据时,该数据被静态所修饰。对象中的特有数据要定义成非静态存在于堆内存中。
什么时候定义静态函数:当功能内部没有访问到非静态数据(对象的特有数据)时,那么该功能可以定义成静态的。
静态的应用:每一个应用程序中都有共性的功能,可以将这些功能进行抽取,独立封装,形成一个工具类,当其他应用程序需要用其中的功能时,找到这个工具类就可以了,方便复用。
示例:
classArrayTool //定义一个操作数组的工具类
{
//定义获取数组中最大值的方法
public static int getMax(int[]arr)
{
int max=0;
for(int i=1;i<arr.length-1;i++)
{
if(arr[i]>arr[max])
max=i;
}
return arr[max];
}
//定义获取数组中最小值的方法
public static int getMin(int[] arr)
{
int min=0;
for(inti=1;i<arr.length-1;i++)
{
if(arr[i]<arr[min])
min=i;
}
return arr[min];
}
//定义将数据进行选择排序的方法
public static void selectSort(int[]arr)
{
for(inti=0;i<arr.length-1;i++)
{
for(intj=i+1;j<arr.length;j++)
{
if(arr[i]>arr[j])
{
inttemp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
}
//定义将数组进行冒泡排序的方法
public static void bubbleSort(int[]arr)
{
for(inti=0;i<arr.length-1;i++)
{
for(intj=0;j<arr.length-i-1;j++)
{
if(arr[j]>arr[j+1])
{
inttemp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
//定义打印数组中元素的方法
public static void arrayPrint(int[]arr)
{
System.out.print("[");
for(inti=0;i<arr.length;i++)
{
if(i!=arr.length-1)
System.out.print(arr[i]+",");
else
System.out.print(arr[i]+"]");
}
}
}
public classArrayDemo5
{
public static void main(String[] args)
{
}
}
说明:定义了一个操作数组的工具类,类中定义了对一个数组取最值、排序和打印的方法,这些方法都定义成静态的,当在其他程序中需要用到该类中的方法去操作数组时,可以直接通过这个工具类的类名去调用相应的方法,而不需要在程序中定义相应的方法,增强了代码的复用性。同时,因为该类是工具类,不需要被实例化,所以可以在该类中将其构造函数私有化,强制该类不能建立对象。
5.8、main函数
主函数是一个特殊的函数,作为程序的入口,可以被JVM调用。
public:代表着该函数访问权限是最大的。
static:代表主函数随着类的加载就已经存在了。
void:主函数没有具体的返回值。
main:不是关键字,但是是一个特殊的单词,可以被JVM识别。
(String[] args):函数的参数,参数类型是一个数组,该数组中的元素是字符串,字符串类型的数组。
主函数是固定格式的:JVM识别。格式:public static void main(String[] args){}。
JVM在调用主函数时,默认传入的是new String[0]。
5.9、静态代码块
作用:随着类的加载而执行,只执行一次。用于给类进行初始化。
格式:static{静态代码块中的执行语句}。
5.10、对象初始化过程:
(1)当用new建立一个对象时,因为new用到了相应类的class文件,所以会先找到相应的class文件并加载到内存中。
(2)执行该类中的static代码块,如果有的话,对该进行初始华。
(3)在堆内存中开辟空间,分配内存地址。
(4)在堆内存中建立对象的特有属性,并进行默认初始化。
(5)对属性进行显式初始化。
(6)对对象进行构造代码块初始化。
(7)对对象进行对应的构造函数初始化。
(8)将内存地址赋给栈内存中的对象变量。
5.11、单例设计模式
单例设计模式指解决一个类在内存中只存在一个对象。
如何保证类的对象唯一:
(1)为了避免其他程序过多建立该对象,先禁止其他程序建立该对象。(将构造函数私有化)。
(2)还为了让其他程序可以访问到该类对象,只好要本类中,自定义一个对象。(在类中创建一个本类对象)。
(3)为了方便其他程序对自定义对象的访问,可以对外提供一些访问方式。(提供一个方法可以获取到该对象)。
单例设计模式的两种方式:
(1)饿汉式:先初始化对象,当类一进内存时就已经创建好了对象。
示例:
class Single
{
private static Single s=new Single(); //创建本类对象并将其私有
private Single(){}
public static Single getInstance() //定义获取本类对象的方法
{
return s;
}
}
(2)懒汉式:对象是在方法被调用时才初始化,也叫做对象的延时加载。即当类进内存时,对象还没有存在,只有调用了方法时才建立对象。
示例:
class Single
{
private static Single s=null; //创建本类对象引用并指向null
private Single(){}
public static Single getInstance()//定义获取本类实例的方法
{
if(s==null) //通过双重判断解决效率的问题
{
synchronized(Single.class) //通过同步代码块解决同步的问题
{
if(s==null)
s=new Single();
}
}
return s;
}
}
说明:由于当多个程序在调用getInstance方法时可能会发生问题,所以需要进行双重判断,并加同步。
原则:定义单例,建议使用饿汉式。