6面向对象入门
导语:
想到在写
1. CarDemo
/*
将面向对象使用落实到代码上。
描述小汽车。
分析:
事物的属性:
颜色。
轮胎个数。
事物的行为(功能):
运行。
发现:事物其实就是由 属性和行为组成的。
可以简单理解:属性就是数值,其实就是变量;行为就是功能,就是函数。
小汽车
{
颜色;
轮胎个数;
运行()
{
}
}
通过计算机语言Java来描述这个事物。
Java描述事物是通过类来完成的。
class Car
{
String color;
int number;
void run()
{
System.out.println(color+"::"+number);
}
}
*/
class Car//类的真正意义就是在描述事物。属性和行为统称为事物中的成员。
//成员分两种:成员属性(在代码中的体现:成员变量)和成员行为(代码体现:就是函数。)
{
//事物的属性。
String color;
int number;
//事物的行为。
void run()
{
System.out.println(color+"::"+number);
}
//主函数没有定义,是可以定义的,就看该类需不需要独立运行。而该类不需要独立运行,所以没有写。
}
//把写好的代码测试一下。需要一个可以独立运行类。
class CarDemo
{
public static void main(String[] args)
{
//测试:Car类中的run方法。
//1,创建Car的对象。给对象起个名字。
Car c = new Car();//c是类类型的变量。c指向了一个具体的Car类型的对象。
//2,通过已有的对象调用该对象的功能。格式:对象.对象成员;
//3,可以该对象的属性赋值。
c.color = "red";
c.number = 4;
c.run();
Car c1 = new Car();
c1.color = "black";
c1.number = 3;
c1.run();//
/*
画图小练习。
Car c = new Car();
Car c1 = new Car();
c1.color = "green";
c.number = 5;
c1.run();//结果是什么?
c = null;//有垃圾吗?
*/
}
}
/*
类与对象关系:
类:对事物的描述。需要体现属性和行为。
对象:该类事物创建的实例(实体),通过该对象调用具有的属性和行为。
成员变量和局部变量的区别:
区别一:定义的位置不同。
成员变量定义在类中。
局部变量定义在方法中以及语句里。
区别二:在内存中的位置不同。
成员变量存储在堆内存的对象中。
局部变量存储在栈内存的方法中。
区别三:生命周期不同。
成员变量随着对象的出现而出现,随着对象的消失而消失。
局部变量随着的方法的运行而出现,随着方法的弹栈而消失。
区别四:初始化不同。
成员变量因为在堆内存中,所有默认初始化值。
局部变量没有默认初始化值,必须初始化后才可以使用。
*/
2. 面向对象
通过 买电脑(组装机) 来理解面向过程和面向对象。
面向过程:
自己做这些事。按照步骤,通过这些过程完成。
1,查信息(了解硬件行情)。
2,查报价(电脑城询价)
3,组装监督。
4,扛回家。
面向对象:
以后买电脑:
因为这些过程我都不了解。
找一个懂行的人。
这个人具备你所需要的功能。
毕老师..(对象)
{
1,查信息(了解硬件行情)。
2,查报价(电脑城询价)
3,组装监督。
4,扛回家。
}
毕老师.查信息。
毕老师.查报价。
毕老师.组装监督。
差异(面向对象的好处:)★★★★★
1,面向对象是一种更符合人们思考习惯的思想。
2,面向过程中更多的体现的是执行者,面向对象中更多的体现是指挥者。
指挥对象做事情。
3,面向对象将复杂的问题简单化了。
在面向对象的世界中:万物皆对象。
------------
面试的时候:
阐述三个好处。
具体化。举例:其实面试官您就是按照面向对象的思想在思考问题。
面试官您本身就可以开发项目,但是项目有可能比较大,一个人开发周期长。
为了提高效率,需要有更多的具备者专业开发能力的人来帮助您做事情。
这个人就是您所需的对象,只要调用这些对象的开发功能就可以完成项目。
只要指挥他们做事情就可以了。
-----------------------------------------------------
面向对象如何应用到需求中。★★★★★
在需求中尽量的去寻找对象。(从问题领域中抽取对象)
最简单的思考访问:一般情况,名词表示的大多是对象。
需求:将大象装进冰箱里。
对象:大象,冰箱。
分三步:
1,打开冰箱门。
2,将大象装进去。
3,关上冰箱门。
冰箱对象中:
打开功能。
关闭功能。
存储功能。
大象
{
}
冰箱//对冰箱事物的描述(说明)。
{
打开(){}
关闭(){}
存储(大象){}
}
使用冰箱中的功能。
1,创建冰箱的对象。
冰箱 bingXiang = new 冰箱();//给对象起名字。
2,调用冰箱的功能。
对象.功能();
bingXiang.打开();
bingXiang.存储(new 大象());
bingXiang.关闭();
总结:
1,先按照名词提取问题领域中的对象。
2,对对象进行描述,其实就是在明确对象中应该具备的属性和功能。
3,通过new的方法就可以创建该事物的具体对象。
4,通过该对象调用它以后的功能。
################################
#自己动手举出两个面向对象的例子#
################################
练习:
人开门。
人
{
开门(门)
{
门.开();
}
}
门
{
门轴;
弹簧;
开()
{
用到门轴;弹簧;
}
}
人刹车。
毕老师用电脑上课。
描述对象:
老师
{
姓名;
使用电脑(电脑)
{
电脑.开();
电脑.运行();
}
讲课()
{
}
}
电脑
{
开(){}
运行(){}
}
老师 毕老师 = new 老师();
毕老师.使用电脑(new 电脑());
毕老师.讲课();
3. 前五天回顾
/*
对前五天的知识点进行简单回顾。
案例1:对数组操作,获取最大值。
思路:
1,一组数,要获取最大的,比较。
2,怎么比较?按个比较。要获取数组中的每一个数据都要比较。
3,比较完,记下来比较大的数据,并用这个较大的数据和下一个数据比较。
不断记录较大的值。
4,如果所有的数据都比较完,那么最后记录的较大值就是最大值。
步骤:
1,需要一个类。
2,这个类需要独立运行,必须有main方法。
3,有一个数组。
4,每一次较大的数据都有可能不同。变量。
5,用数组的数据都获取出来。为了比较。遍历。
6,在遍历过程中,需要比较,判断。
7,每满足一次判断条件,就用变量记录较大的值。变量存储。
*/
//1,需要一个类。
class ArrayDemo
{
//2,这个类需要独立运行,必须有main方法。
public static void main(String[] args)
{
//3,有一个数组。
int[] arr = {23,17,88,42};
//4,每一次较大的数据都有可能不同。变量。
int maxValue = arr[0];//初始化为了数组中的任意一个元素。
//5,用数组的数据都获取出来。为了比较。遍历。for while
for(int i = 1; i < arr.length; i++)
{
//6,在遍历过程中,需要比较,判断。if
//7,每满足一次判断条件,就用变量记录较大的值。变量存储。
if(arr[i] > maxValue)
{
maxValue = arr[i];//只要遍历到的元素大于了maxValue中记录的较大的值,就用maxValue将该更大的值记录下来。
}
}
//8,一旦遍历结束,maxValue中存储的就是该数组的最大值。
// 为了显示出最大值。告诉使用者。输出语句。
System.out.println("arr最大值:"+maxValue);
}
}
/*
int[] arr2 = {34,56,99,10};
案例2:又来了一个数组。还要获取最大值。复制代码并改变量名,怂!
既然代码不变,为什么不提高这段代码的重复使用呢?传说中 复用性。
怎么提高复用?将这部分代码变成一个整体,并给这个整体起个名字(目的为了便于使用这个整体)。
Java中代码变成一个整体,通过函数体现的。所以函数就是一个类中的功能。
*/
class ArrayDemo2
{
public static void main(String[] args)
{
int[] arr = {34,56,99,10};
//获取最大值。需要一个功能。
int maxValue = getMaxValue(arr);
System.out.println("maxValue:"+maxValue);
int[] arr2 = {23,17,88,42};
int maxValue2 = getMaxValue(arr2);
System.out.println("maxValue2:"+maxValue2);
}
//需要getMaxValue功能,而这个功能目前是没有的。所以要自定义功能。提高了复用性。
public static int getMaxValue(int[] arr)
{
int maxValue = arr[0];//初始化为了数组中的任意一个元素。
//1,用数组的数据都获取出来。为了比较。遍历。for while
for(int i = 1; i < arr.length; i++)
{
//2,在遍历过程中,需要比较,判断。if
//3,每满足一次判断条件,就用变量记录较大的值。变量存储。
if(arr[i] > maxValue)
{
maxValue = arr[i];//只要遍历到的元素大于了maxValue中记录的较大的值,就用maxValue将该更大的值记录下来。
}
}
//4,一旦遍历结束,maxValue中存储的就是该数组的最大值。
//5,将该值返回。不要打印,因为不是该功能的职责。
return maxValue;
}
}
/*
案例3:继续升级,很多的类中都有数组,都需要获取其最值。
怎么办?不要复制。
将所需的功能,封装到指定的类中。
*/
class ArrayDemo3
{
public static void main(String[] args)
{
int[] arr = {43,12,56,89};
//想要使用ArrayTool中的功能。需要先建立ArrayTool这个类应用程序的对象。通过new完成。
ArrayTool tool = new ArrayTool();
int maxValue = tool.getMaxValue(arr);//通过tool这个对象调用它的获取最大值的功能。
System.out.println("maxvalue:"+maxValue);
//Arrays.sort(arr);
//获取最小值。
int minValue = tool.getMinValue(arr);
System.out.println("min?Value:"+minValue);
}
}
/*
将操作的最大值功能单独封装到一个类中。
这样使用这个功能只要找到功能所属的类就可以了。
ArrayTool tool = new ArrayTool();//这个就是对象。
int maxValue = tool.getMaxValue(arr);
所有的功能都在对象中。只要找到了对象,就可以使用这些功能。而不需要关注功能的细节。
*/
class ArrayTool
{
//获取最大值。
public /*static*/ int getMaxValue(int[] arr)
{
int maxValue = arr[0];
for(int i = 1; i < arr.length; i++)
{
if(arr[i] > maxValue)
{
maxValue = arr[i];
}
}
return maxValue;
}
//获取最小值。
public /*static*/ int getMinValue(int[] arr)
{
//code...
return 0;//仅为编译通过。
}
//二分查找。折半。
public /*static*/ int binarySearch(int[] arr,int key)
{
return 0;
}
}
/*
之前是面向过程:就是不断的使用函数。
现在将所有的功能进行封装。面对的是封装了功能的实体(对象),面向对象。
面向对象基于面向过程。将过程进行对象的封装。
只要找到了对象,就可以使用对象中的功能。
结论:以后开发,先找对象以及对象的功能。
如果没有,自己创建对象并将所需的功能定义到该对象中。
*/