黑马程序员-------第3天笔记(面向对象)
2014-03-30 17:51
169 查看
-------
android培训、java培训、期待与您交流! ----------
面向对象
面向对象是一种思想
面试题
初始化对象后,对象的属性都有一个默认初始化值null
匿名对象使用方式一:当对对象的方法使用一次时,可以用匿名对象来完成,这样写比较简化
如果对一个对象进行多个成员调用,必须给这个对象起一个名字
匿名对象使用方式二:可以将匿名对象作为实际参数进行传递
框架是一个集成性相当好的工具,他可以帮你实现一些组件的开发
对象一建立就会调用该对象的构造函数
构造函数的作用可以给对象进行初始化(这人啊,一出生就会哭)
构造函数的小细节:当一个类中没有定义构造函数时,那么系统会默认给该类加入一个空参数的构造函数
构造代码块:
作用:给对象进行初始化花,对象一建立就运行,优先于构造函数执行
构造代码块是给所有对象进行统一初始化,而构造函数是给对应的对象进行初始化,把所有对象的共性放在构造代码块里面(小细节用于面试)
3.6
/*
static 关键字
用法:是一个修饰符,用于修饰成员变量函数
党成员被静态修饰后,就多了一种调用方式,除了可以被对象调用外,还可以被直接被类名调用,写法格式是:类名.静态成员
Static的特点:
1. 随着类的加载而加载,随着类的消失而消失,说明它的生命周期最长
2. 优先对对象存在
3. 被所有对象所共享
4. 可以直接被类名调用
实例变量和类变量的区别:
1. 存放位置 类变量随着类的加载而加载而存在于方法区中。实例变量随着对象的建立而存在于堆区中
2. 生命周期 类变量生命周期最长,随着类的消失而消失,实例变量随着对象的消失而消失
3. 有利有弊,利:对对象的共享数据进行单独空间的存储,节省空间。没有必要每个对象中存储一份,可以直接被类名调用。
弊端:生命周期过长,还有访问出现局限性,就是说静态虽好,只能访问静态,而非静态啥都能访问。
静态的使用注意事项:
1. 静态方法只能访问静态成员(方法,变量),非静态方法既可以访问非静态变量也可以访问非静态
2. 静态方法中不可以定义this,super关键字
因为静态优先于对象存在,所以静态方法中不可以存在this关键字
3. 主函数是静态的
*/
class Person
{
Stringname;//成员变量,实例变量
staticString country="美国";//此变量不在堆内存中,静态修饰的内容,被对象所共享
publicvoid show()
{
System.out.println("姓名:"+name+" 国籍:"+country);
}
publicstatic void main(String[] args)
{
//Personp1=new Person();
//p1.name="满兴旺";
//p1.show();
System.out.println(Person.country);//静态变量被类名调用
}
}
内存分配:
解析主函数
/*
主函数是一个特殊的函数:可以被jvm调用,作为程序的入口。
主函数的定义:
public:代表该函数的访问权限是最大的
static:代表主函数随着类的加载就已经存在了。
void:对主函数没有具体的返回值。
main:不是关键字,但是是一个特殊的单词,可以被jvm识别
函数的参数:(String[] args)参数类型是一个数组,该数组中元素是字符串。字符串类型的数组。
主函数是固定格式的虚拟机识别。
*/
class mainDemo
{
publicstatic void main(String[] args) //虚拟机只能识别这个类型的主函数
{
System.out.println("HelloWorld!");
}
}
Args: arguments----简化-àargs 约定的
虚拟机调用时到底传了什么东西。
Jvm调用主函数时调用new String[0];
/**
什么使用静态:
因为静态修饰成员函数和成员变量
什么时候定义静态的变量呢?什么时候定义静态的函数呢?
1. 当对象中出现共享数据时,该数据被静态所修饰(比如传智播客的学生)
对象中的特有数据要定义成非静态存在于堆内存中
2. 静态函数的特点:(只能访问静态变量)当功能内部没有访问到非静态数据(对象的特有数据)该功能定义成静态的
*/
/*
静态的应用
每一个应用程序中都有共性的功能,可以将这些功能进行抽取,独立封装。
以便复用
接下来,将ArrayTool。class文件发送给其他人,其他人只要将该文件设置到classpath路径下,就可以使用该工具类
但是该类中到底定义了多少方法呢。因为该类并没有使用说明书。java的说明书通过文档注释来完成
*/
/**
这是一个可以对数组进行操作的工具类,该类中提供了,获取最值,排序功能等
@author 满兴旺
@version:1.0
记住此类一定要用public修饰
只有两种权限才会提取到文档中去public protected
一个类中默认会有一个空参数的构造函数
这个默认的构造函数的权限和所属类一致
如果类被public 修饰,那么默认的构造函数也带public修饰
API帮助文档 applicationinterface
*/
public class ArrayTool
{
/**
将构造函数私有化,别人不能建立对象。
*/
privateArrayTool(){}
/**
获取一个整形数组中的最大值
@paramarr 接受一个int类型的数组
@return会返回一个数组中的最大值
*/
publicstatic int getMax(int[] arr)
{
intmax=0;
for(inti=1;i<arr.length;i++)
{
if(arr[i]>arr[max])
{
max=i;
4000
}
}
returnarr[max];
}
/**
获取一个整形数组中的最小值
@paramarr 接受一个int类型的数组
@return会返回一个数组中的最小值
*/
publicstatic int getMin(int[] arr)
{
intmin=0;
for(inti=1;i<arr.length;i++)
{
if(arr[i]<arr[min])
{
min=i;
}
}
returnarr[min];
}
/**
给int数组进行选择排序
@paramarr 接受一个int类型的数组
*/
publicstatic void selectSort(int[] arr)
{
for(inti=0;i<arr.length-1;i++)
{
for(intj=i+1;j<arr.length;j++)
{
if(arr[j]<arr[i])
swap(arr,i,j);
}
}
}
/**
给int数组进行冒泡排序
@paramarr 接受一个int类型的数组
*/
publicstatic 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])
swap(arr,j,j+1);
}
}
}
/**
交换数组里两个数的值【注意】此函数被用于排序,可以私有化
@paramarr 接受一个int类型的数组
@i要进行交换元素的角标
@j要进行交换元素的角标
*/
privatestatic void swap(int[] arr,int i,int j)
{
inttemp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
/**
打印数组
*/
publicstatic void printArray(int[] arr)
{
for(inti=0;i<arr.length;i++)
{
System.out.print(arr[i]+"");
}
}
}
Javac ArrayToolDemo时,会编译arraytool文件,会优先在本目录下编译
private ArrayTool(){}//将构造函数私有化,别人不能建立对象。
静态代码块
/*
静态代码块。
格式:
static
{
静态代码块中的执行语句。
}
特点:随着类的加载而执行,只执行一次。用于给类进行初始化的
*/
class StaticCode
{
static
{
System.out.println("这时静态代码块语句");
}
public static void main(String[] args)
{
System.out.println("HelloWorld!");
System.out.println("HelloWorld!");
System.out.println("HelloWorld!");
System.out.println("HelloWorld!");
}
}
Person p=new Person(“张三”,20)
该句话做了什么事情
1. 因为new用到了Person.Class,所以会找到Person。Class文件并加载到内存中
2. 执行该类中的静态代码块(如果有的话),给person.class类进行初始化
3. 在堆内存中开辟空间,分配内存地址。
4. 在堆内存中建立对象的特有属性,并进行默认初始化
5. 对属性进行显示初始化
6. 对对象进行构造代码块初始化
7. 对对象进行对应的构造函数初始化。
8. 将内存地址复制给栈内存的P变量
设计模式
/*
设计模式:解决某一类问题最行之有效的方法
学习资料:《设计模式》-------思想
中国人用筷子,西方人用叉子,这就是设计方式的不同
java中23中设计模式
1.单例设计模式:解决一个类在内存中只存在一个对象
1.为了避免其他程序过多建立该类对象,先控制禁止其他程序建立该类对象
2.还为了让其他程序访问到该类对象,只好在本类中自定义一个对象
3.为了方便其他程序对自定义对象的访问,可以对外提供一些访问方式
2.用代码实现:
1,将构造函数私有化
2,再累中创建一个本类对象
3,提供一个方法可以获取到该对象
对于事物该怎么描述就怎么描述
当需要将该事物的对象保证在内存中唯一时,就可以将以上三步加上即可
*/
class Single
{
privateSingle(){};
intnum;
publicvoid setNum(int num)
{
this.num=num;
}
publicint getNum()
{
returnthis.num;
}
privatestatic Single s=new Single();
publicstatic Single getInstance()
{
returns;
}
}
class SingleDemo
{
publicstatic void main(String[] args)
{
Singles1=Single.getInstance();
s1.setNum(23);
Singles2=Single.getInstance();
System.out.println(s2.getNum());
}
}
Ss s1同指向堆内存中的同一个对象
两种设计模式
/*
这个是先初始化对象
名字:饿汉式【开发时一般用饿汉式,简单,安全】
single类一进内存,就创建好了对象。
class Single
{
privateSingle(){}
privatestatic Single s=new Single();
publicstatic Single getInstance()//返回的应该是一个Single类型的指针
{
returns;
}
}
*/
//对象是方法被调用时,才初始化,也叫做对象的延迟加载。称为懒汉式
//Single类进内存,对象还没有存在,只有调用了getInstance方法时,才建立对象。
class Single
{
privatestatic Single s=null;
privateSingle(){}
publicstatic Single getInstance()
{
if(s==null)
s=newSingle();
returns;
}
}
class SingleDemo2
{
publicstatic void main(String[] args)
{
System.out.println("HelloWorld!");
}
}
-------
android培训、java培训、期待与您交流! ----------
android培训、java培训、期待与您交流! ----------
面向对象
面向对象是一种思想
面试题
初始化对象后,对象的属性都有一个默认初始化值null
匿名对象使用方式一:当对对象的方法使用一次时,可以用匿名对象来完成,这样写比较简化
如果对一个对象进行多个成员调用,必须给这个对象起一个名字
匿名对象使用方式二:可以将匿名对象作为实际参数进行传递
框架是一个集成性相当好的工具,他可以帮你实现一些组件的开发
对象一建立就会调用该对象的构造函数
构造函数的作用可以给对象进行初始化(这人啊,一出生就会哭)
构造函数的小细节:当一个类中没有定义构造函数时,那么系统会默认给该类加入一个空参数的构造函数
构造代码块:
作用:给对象进行初始化花,对象一建立就运行,优先于构造函数执行
构造代码块是给所有对象进行统一初始化,而构造函数是给对应的对象进行初始化,把所有对象的共性放在构造代码块里面(小细节用于面试)
3.6
/*
static 关键字
用法:是一个修饰符,用于修饰成员变量函数
党成员被静态修饰后,就多了一种调用方式,除了可以被对象调用外,还可以被直接被类名调用,写法格式是:类名.静态成员
Static的特点:
1. 随着类的加载而加载,随着类的消失而消失,说明它的生命周期最长
2. 优先对对象存在
3. 被所有对象所共享
4. 可以直接被类名调用
实例变量和类变量的区别:
1. 存放位置 类变量随着类的加载而加载而存在于方法区中。实例变量随着对象的建立而存在于堆区中
2. 生命周期 类变量生命周期最长,随着类的消失而消失,实例变量随着对象的消失而消失
3. 有利有弊,利:对对象的共享数据进行单独空间的存储,节省空间。没有必要每个对象中存储一份,可以直接被类名调用。
弊端:生命周期过长,还有访问出现局限性,就是说静态虽好,只能访问静态,而非静态啥都能访问。
静态的使用注意事项:
1. 静态方法只能访问静态成员(方法,变量),非静态方法既可以访问非静态变量也可以访问非静态
2. 静态方法中不可以定义this,super关键字
因为静态优先于对象存在,所以静态方法中不可以存在this关键字
3. 主函数是静态的
*/
class Person
{
Stringname;//成员变量,实例变量
staticString country="美国";//此变量不在堆内存中,静态修饰的内容,被对象所共享
publicvoid show()
{
System.out.println("姓名:"+name+" 国籍:"+country);
}
publicstatic void main(String[] args)
{
//Personp1=new Person();
//p1.name="满兴旺";
//p1.show();
System.out.println(Person.country);//静态变量被类名调用
}
}
内存分配:
解析主函数
/*
主函数是一个特殊的函数:可以被jvm调用,作为程序的入口。
主函数的定义:
public:代表该函数的访问权限是最大的
static:代表主函数随着类的加载就已经存在了。
void:对主函数没有具体的返回值。
main:不是关键字,但是是一个特殊的单词,可以被jvm识别
函数的参数:(String[] args)参数类型是一个数组,该数组中元素是字符串。字符串类型的数组。
主函数是固定格式的虚拟机识别。
*/
class mainDemo
{
publicstatic void main(String[] args) //虚拟机只能识别这个类型的主函数
{
System.out.println("HelloWorld!");
}
}
Args: arguments----简化-àargs 约定的
虚拟机调用时到底传了什么东西。
Jvm调用主函数时调用new String[0];
/**
什么使用静态:
因为静态修饰成员函数和成员变量
什么时候定义静态的变量呢?什么时候定义静态的函数呢?
1. 当对象中出现共享数据时,该数据被静态所修饰(比如传智播客的学生)
对象中的特有数据要定义成非静态存在于堆内存中
2. 静态函数的特点:(只能访问静态变量)当功能内部没有访问到非静态数据(对象的特有数据)该功能定义成静态的
*/
/*
静态的应用
每一个应用程序中都有共性的功能,可以将这些功能进行抽取,独立封装。
以便复用
接下来,将ArrayTool。class文件发送给其他人,其他人只要将该文件设置到classpath路径下,就可以使用该工具类
但是该类中到底定义了多少方法呢。因为该类并没有使用说明书。java的说明书通过文档注释来完成
*/
/**
这是一个可以对数组进行操作的工具类,该类中提供了,获取最值,排序功能等
@author 满兴旺
@version:1.0
记住此类一定要用public修饰
只有两种权限才会提取到文档中去public protected
一个类中默认会有一个空参数的构造函数
这个默认的构造函数的权限和所属类一致
如果类被public 修饰,那么默认的构造函数也带public修饰
API帮助文档 applicationinterface
*/
public class ArrayTool
{
/**
将构造函数私有化,别人不能建立对象。
*/
privateArrayTool(){}
/**
获取一个整形数组中的最大值
@paramarr 接受一个int类型的数组
@return会返回一个数组中的最大值
*/
publicstatic int getMax(int[] arr)
{
intmax=0;
for(inti=1;i<arr.length;i++)
{
if(arr[i]>arr[max])
{
max=i;
4000
}
}
returnarr[max];
}
/**
获取一个整形数组中的最小值
@paramarr 接受一个int类型的数组
@return会返回一个数组中的最小值
*/
publicstatic int getMin(int[] arr)
{
intmin=0;
for(inti=1;i<arr.length;i++)
{
if(arr[i]<arr[min])
{
min=i;
}
}
returnarr[min];
}
/**
给int数组进行选择排序
@paramarr 接受一个int类型的数组
*/
publicstatic void selectSort(int[] arr)
{
for(inti=0;i<arr.length-1;i++)
{
for(intj=i+1;j<arr.length;j++)
{
if(arr[j]<arr[i])
swap(arr,i,j);
}
}
}
/**
给int数组进行冒泡排序
@paramarr 接受一个int类型的数组
*/
publicstatic 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])
swap(arr,j,j+1);
}
}
}
/**
交换数组里两个数的值【注意】此函数被用于排序,可以私有化
@paramarr 接受一个int类型的数组
@i要进行交换元素的角标
@j要进行交换元素的角标
*/
privatestatic void swap(int[] arr,int i,int j)
{
inttemp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
/**
打印数组
*/
publicstatic void printArray(int[] arr)
{
for(inti=0;i<arr.length;i++)
{
System.out.print(arr[i]+"");
}
}
}
Javac ArrayToolDemo时,会编译arraytool文件,会优先在本目录下编译
private ArrayTool(){}//将构造函数私有化,别人不能建立对象。
静态代码块
/*
静态代码块。
格式:
static
{
静态代码块中的执行语句。
}
特点:随着类的加载而执行,只执行一次。用于给类进行初始化的
*/
class StaticCode
{
static
{
System.out.println("这时静态代码块语句");
}
public static void main(String[] args)
{
System.out.println("HelloWorld!");
System.out.println("HelloWorld!");
System.out.println("HelloWorld!");
System.out.println("HelloWorld!");
}
}
Person p=new Person(“张三”,20)
该句话做了什么事情
1. 因为new用到了Person.Class,所以会找到Person。Class文件并加载到内存中
2. 执行该类中的静态代码块(如果有的话),给person.class类进行初始化
3. 在堆内存中开辟空间,分配内存地址。
4. 在堆内存中建立对象的特有属性,并进行默认初始化
5. 对属性进行显示初始化
6. 对对象进行构造代码块初始化
7. 对对象进行对应的构造函数初始化。
8. 将内存地址复制给栈内存的P变量
设计模式
/*
设计模式:解决某一类问题最行之有效的方法
学习资料:《设计模式》-------思想
中国人用筷子,西方人用叉子,这就是设计方式的不同
java中23中设计模式
1.单例设计模式:解决一个类在内存中只存在一个对象
1.为了避免其他程序过多建立该类对象,先控制禁止其他程序建立该类对象
2.还为了让其他程序访问到该类对象,只好在本类中自定义一个对象
3.为了方便其他程序对自定义对象的访问,可以对外提供一些访问方式
2.用代码实现:
1,将构造函数私有化
2,再累中创建一个本类对象
3,提供一个方法可以获取到该对象
对于事物该怎么描述就怎么描述
当需要将该事物的对象保证在内存中唯一时,就可以将以上三步加上即可
*/
class Single
{
privateSingle(){};
intnum;
publicvoid setNum(int num)
{
this.num=num;
}
publicint getNum()
{
returnthis.num;
}
privatestatic Single s=new Single();
publicstatic Single getInstance()
{
returns;
}
}
class SingleDemo
{
publicstatic void main(String[] args)
{
Singles1=Single.getInstance();
s1.setNum(23);
Singles2=Single.getInstance();
System.out.println(s2.getNum());
}
}
Ss s1同指向堆内存中的同一个对象
两种设计模式
/*
这个是先初始化对象
名字:饿汉式【开发时一般用饿汉式,简单,安全】
single类一进内存,就创建好了对象。
class Single
{
privateSingle(){}
privatestatic Single s=new Single();
publicstatic Single getInstance()//返回的应该是一个Single类型的指针
{
returns;
}
}
*/
//对象是方法被调用时,才初始化,也叫做对象的延迟加载。称为懒汉式
//Single类进内存,对象还没有存在,只有调用了getInstance方法时,才建立对象。
class Single
{
privatestatic Single s=null;
privateSingle(){}
publicstatic Single getInstance()
{
if(s==null)
s=newSingle();
returns;
}
}
class SingleDemo2
{
publicstatic void main(String[] args)
{
System.out.println("HelloWorld!");
}
}
-------
android培训、java培训、期待与您交流! ----------
相关文章推荐
- 【黑马程序员】方法、数组、面向对象、封装、继承——Java复习笔记
- 黑马程序员------毕老师视频笔记第六天------面向对象(static关键字)
- 黑马程序员---java学习笔记之面向对象:继承
- 黑马程序员---学习笔记(1)面向对象
- 黑马程序员------毕老师视频笔记第九天------面向对象(内部类)
- 黑马程序员——面向对象<二> 笔记第四篇
- 黑马程序员------毕老师视频笔记第五天------面向对象(构造函数)
- 黑马程序员------毕老师视频笔记第八天------面向对象(Object类)
- 黑马程序员 java学习笔记——面向对象1:封装
- 黑马程序员_学习笔记第5天——面向对象
- 黑马程序员——面向对象<三> 笔记第五篇
- 黑马程序员------毕老师视频笔记第五天------面向对象(this关键字)
- 黑马程序员------毕老师视频笔记第七天------面向对象(final关键字)
- 黑马程序员-------面向对象的封装、继承、多态一些学习笔记
- 黑马程序员——Java要点笔记——面向对象(二)
- 黑马程序员——.NET笔记7 面向对象 类
- 黑马程序员 笔记(七)——面向对象(继承、抽象类、接口)
- 黑马程序员——JAVA学习笔记——面向对象(三大特性)
- 黑马程序员——OC笔记之面向对象三大特征(封装、继承、多态)
- 黑马程序员——Java学习笔记之②——“面向对象”