面向对象编程详解与实例-优快云博客

本文链接：https://blog.youkuaiyun.com/zw19921122/article/details/45050397

------- android培训、java培训、期待与您交流！ ----------

面向对象:

1、面向对象是相对面向过程而言。

2、面向对象和面向过程都是一种思想。

3、面向过程

强调的是功能行为。

4、面向对象

将功能封装进对象，强调具备了功能的对象。

5、面向对象是基于面向过程的。

那么什么是对象（Object），什么是类（class）？

类是广泛的概念，表示一个具有相同属性和方法的多个对象的集合，是一个有共同性质的群体，而对象，所谓“万物皆对象”，指的是具体的一个实实在在的东西。

例如，“人”是一个类，它可以表示地球上所有的人；而“张三”、“李四”、“王五”等则是一个个的对象，或者说它们是“人”这个类的一个个实例。在 Java 中，我们可以定义类，然后创建类的对象。

声明一个Person这个类

class Person
{
	private String name;
	private int age;
	
	public Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	
}

然后通过一个类来创建对象。

Person p = new Person("zhangsan", 18);

程序执行到这里之后，Java虚拟机将会在内存中创建一个Person对象，并将这个对象的引用给Person变量。这里有三步，首先是创建一个名字为Person的Person类型的句柄，其次，声明一Person对象，然后把创建的对象的引用赋给Person变量。并且将zhangsan和20传递给该对象所拥有的属性。也可能有创建空参数的构造函数。

可以理解为有的人生下来就有姓名，而有的人出生后还没有姓名。这就是人这个对象。

从图中可以看出冰箱具有打开，存储，关闭冰箱这三个属性。对于这三个属性来说它一定都是属于冰箱的。我们所看到的这些属性都是被封装在了冰箱的内部，并不知道它的门是怎样实现打开，关闭的。只是动手给冰箱发出一个指令-->冰箱你把你的门关上。至于它是怎样操控轴承去关，关到什么地步才算关上的，是不是我们都不用去管，也管不了。因为我们根本看不到它内部的任何东西。这时候我们只需要面对冰箱去发出指令。

这时候的我们就可以很明确的肯定是在调用冰箱这个类的关门的方法。冰箱是一类事物，而你面对的冰箱，只是这一类事物中的其中一个对象，而最基本的冰箱又具有制冷，开门关门，存储这些基本功能。但是具体冰箱制冷的时候又具有了冷藏，保鲜。开关门又具有单开门双开门，滑动门。但是我们又不知道冰箱是怎样实现的制冷，关门等功能。

那么我们在冰箱这个示例中完全可以提炼出面向对象的三大精华！封装，继承，多态。

面向对象的三个特征：封装，继承，多态。

以后开发：其实就是找对象使用，没有对象，就创建一个。

找对象，建立对象，使用对象，维护对象的关系。

类就是：对象是生活中事物的描述。

对象：就是这类事物，实实在在存在个体。

封装：其实就是指我们并不了解冰箱具体是怎样实现它的制冷，开关门。但是我们知道它有这个功能拿过来用就行了。

继承：冰箱这一类事物它一定具有的功能或者属性就是制冷，开关门。相当于就是最早的冰箱就是所有冰箱的“父亲”就是父类或者基类，然后后面的冰箱是不是都继承了这些属性，而后在这些基础上改进制冷，让他具有保鲜，冷藏。双开门等特性。但这些都是来自于冰箱最基本的属性。无法改变。也无法缺失。你想想当你的冰箱没有制冷功能还叫冰箱吗？没有门你还会要吗？这也就是面向对象三大特写之一的继承。

多态：其实就是我在继承里面写到的制冷的改进，开门的改进，就是多态，是不是在制冷这个机制上有了多种表现形式，有冷藏，保鲜形式它们体现的都是冰箱这个事物的制冷属性。也就是一个属性的多种体现形式。就是面向对象的多态。

成员变量和局部变量

作用范围：

成员变量作用于整个类中。

局部变量作用于函数中，或者语句中（for）

在内存中的位置：

成员变量：在对内存中，因为对象的存在，才在内存中存在。

局部变量：存在与栈内存中。

下面是变量的一些集中体现：

class Test1 
{
	/*
	现实生活中的对象：张三，李四
	想要描述：提取对象中的共性内容，对具体的抽象。
	描述时：这些对象的共性有：姓名，年龄，姓名，学习JAVA功能。
	映射到java中，就是描述class定义的类
	具体对象就是对应java在堆内存中用new建立实体。
	*/
	public static void main(String[] args) 
	{
		//生产汽车，在java中通过new操作符来完成。
		//其实就是在堆内存中产生一个实体。
		//Car c = new Car();
		//需求：将已有车的颜色改成蓝色，指挥该对象做事情，在java中的指挥方式是：对象.对象成员。
		//c.color = "blue";
		//System.out.println("Hello World!");//c就是一个类类型变量。记住类类型变量指向对象。
		//Car c = new Car(); //起了一个名字c;
		//c.num = 5;
		//new Car().num = 5;
		//new Car().color = "blue";
		//new Car().run();
		//匿名对象使用方式一、当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化
		//可是对一个对象进行多个成员调用，必须给这个对象起个名字。
		//匿名对象的使用方式二、可以将匿名对象作为实际参数进行传递。
		
		Car q = new Car();
		show(q);//show(new Car())匿名对象的使用方法二。
	}
	//需求：汽车修配厂，对汽车进行改装，将来的车都改成黑色，三个轮胎。
	public static void show(Car c)
	{
		c.num = 3;
		c.color = "black";
		c.run();
	}
}
//需求：描述一个汽车（颜色，轮胎数）。描述事物的属性和行为。
//属性对应的是变量，行为对应的是函数（方法）。
//其实定义类，就是在描述事物，就是在定义属性和行为。
//属性和行为共同成为类中的成员（成员变量）。
class Car
{
	//描述颜色
	String color = "红色";
	//描述轮胎数
	int num = 4;
	//运行行为
	void run()
	{
		System.out.println(color+".."+num);
	}
}

在上面的代码中出现了在一个Person类中含有这样一对函数

<span style="white-space:pre">	</span>public Person()
	{
	}
	
	public Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}

在其中方法名一样但是却有不同的参数。这种形式我们就称之为函数的重载。

什么叫做重载？

记住几个关键点：同类，同名，不同参，与返回类型无关，访问修饰无关，抛出异常无关。

重载：
在同一个类中，方法名相同，参数列表不同，所引起的两个方法的差异叫做重载，
• 在同一个类中
• 方法名相同
• 参数列表不同---
• 参数的类型不同
• 参数的个数不同
• 参数的顺序不同
• 与访问修饰符无关
• 与返回值无关
• 与抛出异常无关

这就是重载就是一个属性的不同体现形式！

那么刚才在介绍冰箱这个类的时候又提到了制冷的不同方式，但是它依然属于制冷。毫无疑问这个不同的制冷方式是继承自冰箱的基类，

那么在面向对象中这个子类中拥有的制冷方式与父类中的制冷方式不同又体现了什么呢？

这里就出现了一个新的名词叫做重写。

什么又叫做重写呢？

在冰箱这个例子中我们可以了解到制冷时继承自父类的，但是它拥有了不同的方法。那么这个子类的这个不同的方法，就叫做重写了父类中的具有相同功能的方法。只是用到了不同的体现形式。

重载的关键字：不同类，同名，同参，同返回，访问修饰不能更严格，抛出异常不能更广泛。

重写：在存在父子继承关系的前提下，子类把从父类继承过来的方法，完全重写编写的过程叫做重写。
• 在父子类之间
• 方法名相同
• 参数列表相同
• 返回类型相同
• 访问修饰符，不能更加严格
• 抛出异常，不能更加广泛

这就是在以后Java中广为应用的重写机制。

封装：是指影藏对象的属性和实现细节，仅对外提供公共访问方式。

好处：

将变化隔离。

便于使用。

提高重用性。

提高安全性。

封装原则：

将不需要对外提供的内容都隐藏起来。

将属性都隐藏，提供公共方法对其访问。

函数就是java中最小的封装体。

构造函数：

特点：函数名与类名相同。

不用定义返回值类型。

不可以写return语句。

作用：

给对象进行初始化。

注意：默认构造函数的特点、多个构造函数是以重载的形式存在的。

如果不明显的指定类的构造方法，Java会为每个类隐式的生成一个不带任何参数的构造方法，如果明显制定了任何一个合法的构造方法，Java都不会为你默认生成

构造方法是最先执行的方法(但是晚于静态代码块和非静态代码块)

构造方法不能继承，更不可以被重写,构造方法可以被重载,抽象类/接口没有构造方法，因为抽象类/接口不需要产生对象

this(?)关键字是运行本类的构造方法，super(?)关键字是用来运行父类的构造方法。

class Teacher{      
	pubic int Teacher(int i){           
	return 0; 
<span style="white-space:pre">	</span>} 
} 
上面方法不是构造方法，只不过是一个与类同名的普通方法。

既然谈到了this我们就来看看this关键字：

this关键字：

this：看上去是用于区分局部变量和成员变量同名的情况。

this为什么可以解决这个问题呢？

this到底代表的是什么呢？

this：就代表本类对象。到底代表哪一个呢？

this:代表所在函数所属对象的引用。

简单说叫做哪个对象在调用this所在的函数，this就代表哪个对象。

/*
	this的应用：当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。
	但凡本类功能内部使用到了本类对象，都用this表示。
*/
class Test3 
{
	public static void main(String[] args) 
	{
		//Person p = new Person();
		//Person p1 = new Person("aa");
		//p1.setName("xx");
		//Person p2 = new Person("bb",10);
		//System.out.println(p1.getName());
		Person p1 = new Person(20);
		Person p2 = new Person(25);
		boolean b = p1.compare(p2);
		System.out.println(b);
	}
}
/*
构造函数：对象一建立就会调用预制对应的构造函数。
构造函数的作用：可以用于给对象进行初始化！
构造函数的小细节：
当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。person();
当在类中自定义了构造函数后，默认的构造函数就没有了。
构造函数和一般函数在写法上不同，在运行上也有不同。
构造函数是在对象一建立就运行，而一般方法是，对象调用才执行,是给对象添加对象具备的功能。
一个对象建立，构造函数只运行一次。
而一般方法可以被对象调用多次。
什么时候定义构造函数呢？
当分析事物时，该事物存在就具备一些特性或者行为，那么将这些内容定义在构造函数中。
*/
class Person 
{
	private String name;
	private int age;
	/*
		构造代码块。
		作用：给对象进行初始化。
		对象一建立就运行，而且优先于构造函数执行。
		和构造函数的区别：
		构造代码块是给所有对象进行统一初始化。
		而构造函数是给对应的对象进行初始化。
		构造代码块中定义的是不同对象的共性的初始化内容。
	*/
	{
		//System.out.println("person code run");
		cry();//他们的共性，一出生不管有没有名字都会哭。就定义在构造代码块中。
	}
	Person(int age)
	{
		this.age = age;
	}
	Person()
	{
		System.out.println("A:name="+name+",age="+age);
		//cry();
	}
	Person(String name)
	{
		this.name = name;
		System.out.println("b:name="+name+",age="+age);
		//cry();
	}
	Person(String name,int age)
	{
		//this.name = name; 
		this(name);//构造函数内部调用用该句，调用的就是Person(String name)方法，传了一个name进去。只能定义在构造函数的第一个语句；
		this.age = age;
		System.out.println("c:name="+name+",age="+age);
		//cry();
	}
	public void cry()
	{
		System.out.println("cry......");
	}
	/*
		this：看上去是用于区分局部变量和成员变量同名的情况。
		this为什么可以解决这个问题呢？
		this到底代表的是什么呢？
		this：就代表本类对象。到底代表哪一个呢？
		this:代表所在函数所属对象的引用。
		简单说叫做哪个对象在调用this所在的函数，this就代表哪个对象。
		一般函数不能调用构造函数。
	*/
	public void setName(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return name;
	}
	/*
		需求：给人定义一个用于比较年龄是否相同的功能，也就是是否是同龄人。
		
	*/
	public boolean compare(Person p)
	{
		return this.age == p.age;
	}
}

以上代码是我看毕老师的视频提到的一些知识点。既然提到了this，那么我们下面再来看看很常用的static（静态）关键字：

static(静态)关键字：

static关键字：

用于修饰成员（成员变量和成员函数）

被修饰后的成员具备以下特点：

随着类的加载而加载。//也就是说：静态会随着类的消失而消失，说明他的生命周期最长。

优先于对象存在。//静态是先存在的，对象是后存在的！

被所有对象所共享。

可以直接被类名调用。

使用注意：

静态方法只能访问静态成员。

静态方法中不可以写this，super关键字。

主函数是静态的。

用法：是一个修饰符，用于修饰成员（成员变量，成员函数）。

当成员被静态修饰后，就多了一种调用方式，除了可以被对象调用外，还可以直接被类名调用。类名.静态成员。

System.out.println(p.Person);

System.out.println(Person.country);//这就是用static修饰后用类名.静态成员调用的。

静态的使用注意事项：

1、静态方法只能访问静态成员；

非静态方法既可以访问静态也可以访问非静态。

2、静态方法中不可以定义this，super关键字。

因为静态优先于对象存在，所以静态方法中不可以出现this。

静态有利有弊

利：对对象的共享数据进行单独空间的存储，节省空间，没有必要每一个对象中都存储一份。

可以直接被类名调用。

弊：生命周期过长。

访问出现局限性。（静态只能访问静态成员，类变量）

什么时候使用静态？

要从两方面下手：

因为静态修饰的内容有成员变量和函数。

什么时候定义静态变量（类变量）呢？

当对象中出现的共享数据时。该数据被静态所修饰。

对象中的特有数据要定义成非静态存在于堆内存中。

什么时候定义静态函数呢？

当功能内部没有访问到非静态数据（对象的特有数据）。

那么该功能可以定义成静态的。

下面代码就可以表现出statci的精华。

未声明为static 
class ClassA{ 
	int b; 
	public void ex1(){ 
		… 
	} 
} 
class ClassB{ 
	void ex2{ 
	int i; 
		ClassA a = new ClassA(); 
		i = a.b; //这里通过对象引用访问成员变量b 
		a.ex1; //这里通过对象引用访问成员函数ex1 
	} 
} 

声明为static 
class ClassA{ 
		static int b; 
		static void ex1(){ 
		… 
	} 
} 
class ClassB{ 
	void ex2{ 
		int i; 
		i = ClassA.b; //这里通过类名访问成员变量b 
		ClassA.ex1; //这里通过类名访问成员函数ex1 
	} 
}

静态的应用：

我们可以通过一些简单的功能类来体现出静态在函数之间的应用。

/*
静态的应用。
每个应用程序中都有共性的功能。
可以将这些功能进行抽取，独立封装。以便复用。
虽然可以通过建立ArrayTool的对象使用这些工具，对数组进行操作。
发现了问题：
	1、对象是用于封装数据的，可是ArrayTool对象并未封装特有数据。
	2、操作数组的每一个方法都没有用到ArrayTool对象中的特有数据。
这是就考虑，让程序更严谨，是不需要对象的。
可以将ArrayTool中的方法都定义成static的，直接通过类名调用即可。
将方法都静态后，可以方便于使用，但是该类还是可以被其他程序建立对象的。
为了更严谨，强制让该类不能建立对象。
可以通过构造函数私有化完成。
*/
class ArrayTool
{
	private ArrayTool(){}
	public static int getMax(int[] arr)
	{
		int max = 0;
		for(int x=1;x<arr.length;x++)
		{
			if(arr[x]>arr[max])
				max = x;
		}
		return arr[max];
	}
	public static int getMin(int[] arr)
	{
		int min = 0;
		for(int x=1;x<arr.length;x++)
		{
			if(arr[x]<arr[min])
				min = x;
		}
		return arr[min];
	}
	public static void selectSort(int[] arr)
	{
		for (int x=0;x<arr.length ;x++ )
		{
			for (int y=x+1;y<arr.length ;y++ )
			{
				if(arr[x]>arr[y])
				{
					swap(arr,x,y);
				}
			}
		}
	}
	public static void bubbleSort(int[] arr)
	{
		for (int x=0;x<arr.length ;x++ )
		{
			for (int y=0;y<arr.length-x-1 ;y++ )
			{
				if(arr[y]>arr[y+1])
				{
					swap(arr,y,y+1);
				}
			}
		}
	}
	private static void swap(int[] arr,int a,int b)
	{
		int temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}
	public static void printArray(int[] arr)
	{
		System.out.print("[");
		for (int x=0;x<arr.length ;x++ )
		{
			if(x!=arr.length-1)
				System.out.print(arr[x]+",");
			else
				System.out.println(arr[x]+"]");
		}
	}
}
/*
class Demo
{
	public static void main(String args[])
	{
		int[] arr = {3,4,1,8};
		int max = getMax(arr);
		System.out.println("max="+max);
	}
	//取数组中的最大值。
	public static int getMax(int[] arr)
	{
		int max = 0;
		for(int x=1;x<arr.length;x++)
		{
			fi(arr[x]>arr[max])
				max = x;
		}
		return arr[max];
	}
}
class Test
{
	public static int getMax(int[] arr)
	{
		int max = 0;
		for(int x=1;x<arr.length;x++)
		{
			fi(arr[x]>arr[max])
				max = x;
		}
		return arr[max];
	}
}
*/

通过ArrayToolDemo调用：

class ArrayToolDemo 
{
	public static void main(String[] args) 
	{
		int[] arr = {3,1,87,32,8};
		int max = ArrayTool.getMax(arr);
		System.out.println("max="+max);
		/*
		int[] arr = {3,1,87,32,8};
		ArrayTool tool = new ArrayTool();
		int max = tool.getMax(arr);
		int min = tool.getMin(arr);
		System.out.println("max="+max);
		System.out.println("min="+min);
		tool.printArray(arr);
		tool.selectSort(arr);
		tool.printArray(arr);
		*/
	}
}

以上这些例子完全看出来在定义函数时，如果并没有操作到特有的数据比如说向π这一的常量时就可以定义为static函数。

而在调用静态函数的时候完全可以通过类名来调用，使得调用简单了很多。

------- android培训、java培训、期待与您交流！ ----------

详细请查看：www.itheima.com