黑马程序员——面向对象
-----------android培训、java培训、java学习型技术博客、期待与您交流!------------
一、this关键字
This :用于区分局部变量和成员变量同名情况
特点:this就代表本类对象,到底代表哪一个呢?
代表它所在函数所属对象的引用。简单说对象在调用this所在函数,this就代表那个对象。
class Person{
private String name;
private int age;
Persom(String name,int age){
this.name=name;
this.age=age;
}
Public void speak(){
System.out.println(name+age);
}
}
class personD{
public static void main(String[] args){
Person p=new Person(“lisi”,45);
}
}
This 的应用:当定义类中的功能时,该函数内部要用到调用该函数的对象时,这时this来表示这个对象。但凡本类功能内部使用了本类对象,都用this表示。
实例:给人定义一个用于比较年龄是否相同的功能。
class Person{
private String name;
private int age;
Person(int age){
this.age=age;
}
Public boolean compare(Person p){
return this.age==p.age;
}
}
class personD{
public static void main(String[] args){
Person p1=new Person(45);
Person p2=new Person(34);
boolean b=p1.compare(p2);
}
}
二、static关键字
静态:static
用法:是一个修饰符,用于修饰成员(成员变量,成员函数)
当成员被静态修饰后,就多了一个调用方式,出了可以被对象调用外,还可以直接百日类名调用。格式:类名.静态成员。
class Person{
String name;//实例变量,成员变量
static String country=”China”;//类变量,静态成员变量
Public void show(){
System.out.println(name+country);
}
}
class personD{
public static void main(String[] args){
System.out.println(person.country);
}
}
Static特点:
1.随着类的加载而加载。也就是说,静态会随着类的消失而消失,说明它的生命周期最长
2.优先于对象存在
3.被所有对象所共享
4.可以直接被类名所调用
实例变量和类变量的区别:
1.存放位置
类变量随着累的加载而存在方法区中
实例变量随着对象的建立而存在于堆内存中
2.生命周期
类变量生命周期最长,随着类的消失而消失。
实例变量生命周期随着对象的消失而消失。
静态的使用注意事项:
1.静态方法只能访问静态成员
非静态方法即可以访问静态也可以访问非静态
2.静态方法中不可以定义this,super关键字
因为静态优先于对象存在,所以静态方法中不可以出现this
3.主函数是静态的
主函数是一个特殊的函数,作为程序的入口,可以被jvm调用
主函数的定义:
Public 代表该函数访问权限是最大的
Static 代表主函数随着累的加载就已经存在了
Void 主函数没有具体的返回值
Main 不是关键字,但是是一个特殊的单词,可以被jvm识别。
静态利弊:
利:对对象的共享数据进行单独空间的存储,节省空间。没有必要每个对象中都存储一份。可以直接被类名调用。
弊:生命周期过长,访问出现局限性。(静态只能访问静态)
什么时候使用静态?
要从两个方面下手:
因为静态修饰的内容有成员变量核函数
什么时候定义静态变量(类变量)?
当对象中出现共享数据时,该数据被静态所修饰。对象中的特有数据要定义成非静态存在于堆内存中。
什么时候定义静态函数?
当功能内部没有访问到非静态数据(对象特有的数据),那么该功能可以定义成静态。
静态的应用:
每一个应用程序中都有共性的功能。可以将这些功能进行抽取,独立封装,以便服用。
class tool{
Public static int Max(int[] arr){
Int max=0;
For(int x=1;x<aee.length;x++){
If(arr[x]>arr[max])
Max=x;
}
Return arr[max];
}
Public static int Min(int[] arr){
Int min=0;
For(int x=1;x<aee.length;x++){
If(arr[x]<arr[max])
min=x;
}
Return arr[min];
}
Public static nt sort(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]){
Int temp=arr[x];
Arr[x]=arr[y];
Arr[y]=temp;
}
}
If(arr[x]<arr[max])
min=x;
}
Return arr[min];
}
}
Class Tools{
Public static void main(String[] args){
Int[] arr={1,3,4,5,6};
/*Tool t=new tool();
Int max=t,Max(arr);
Int min=t.Min(arr):
Int[] a=t.sort(arr);*/
Int max=tool.Max(arr);
Int min=tool.Min(arr);
Int[] a=tool.sort(arr);
}
}
虽然可以通过建立tool的对象使用这些工具方法,对数组进行操作。发现了问题:
1.对象是用于封装数据的,可是tool对象并未封装特有数据。
2.操作数组的每一个方法都没有用到tool对象中的特有数据
这时就考虑让程序更严谨,是不需要对象的。可以将tool中的方法都定义成static,直接通过内名调用即可
将方法静态后,可以方便与使用,但是该类还是可以被其他程序建立对象的。为了更严谨,强制让该类不能建立对象,可以通过将构造函数私有化完成。
三、单例设计模式
设计模式:解决某一类问题最行之有效的方法。
Java中有23中设计模式。
单例设计模式:解决一个类在内存只存在一个对象。
想要保证对象的唯一:
1.为了避免其他程序过多建立该类对象,先禁止其他程序建立该类对象
2.为了其他程序可以访问到该类对象,只好在本类中自定义一个对象
3.为了方便其他程序对自定义对象的访问,可以对外提供一些访问方式。
做法:
1.将构造函数私有化
2.将类中创建一个本类对象
3.提供一个方法获取打该对象
Class Single{
Private Single(){}
private static Single s=new Single();
Public static ingle getInstance(){
Return s;
}
}
Class SingleD{
Public static void main(String[] args){
Single ss=Single.getInstance();
}
}
对于事物该怎么描述就怎么描述,当需要将该事物的对象保证在内存中唯一时,就将以上三部加上即可。
先初始化对象的叫做饿汉式:
Class Single{
Private Single(){}
private static Single s=new Single();
Public static ingle getInstance(){
Return s;
}
}
对象是方法被调用时才初始化,也叫做对象的延时加载,称为懒汉式
Single 类进内存,对象还没有存在,只有调用getInstance方法时才建立对象
Class Single{
Private static Single s=null;
Private Single(){}
Public static ingle getInstance(){
If(s=null)
s=new Single();
Return s;
}
}
原则:定义单例,建议使用饿汉式。