黑马程序员 ——面向对象

最新推荐文章于 2018-04-05 19:31:50 发布

路漫漫求索

最新推荐文章于 2018-04-05 19:31:50 发布

阅读量455

点赞数

分类专栏： JAVA

本文链接：https://blog.csdn.net/u014398480/article/details/29558211

版权

JAVA 专栏收录该内容

36 篇文章 0 订阅

订阅专栏

---------------------- 黑马程序员 Android培训、期待与您交流！ ----------------------

面向对象

在Java中，高手们的概念就是万物皆对象。

面向对象的概念：

面向对象：是基于面向过程的一种思想。

面向过程：强调的是功能行为。

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

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

例如：开门

我们想开门，就是在指挥门的打开功能。

具体开门的动作是门自动完成的，具体门是怎么完成开门动作的，我们不管。因为它具备打开的功能，我们想开门，只要调用它的打开功能，只要结果。

例2：服务员

当我们去饭管吃饭的时候，我们要叫服务员点餐，我们只要说出菜的名称，服务员就把菜单拿给厨师去做，厨师就具备炒菜的功能，炒完后我们只要看这菜能吃，就行。

我们想吃这个菜就是过程。具体怎么做出来的就是过程。

面向对象和面向过程：

图例：

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

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

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

类与对象的关系

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

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

想要描述：提取对象中共性内容。对具体的抽象。

映射到Java中描述就是class定义的类。

具体对象就是对应Java在堆内存中用new建立实体。

例子：

需求：描述小汽车。描述事物其实就是在描述事情的属性和行为。

分析：

1、属性：轮胎数。颜色。

2、行为：运行。

定义类其实就是在定义类中的成员。（成员：成员变量<-->属性，成员函数<-->行为。）

属性对应是类中变量，行为对应的类中函数或方法。

其实定义类，就是在描述事物，就是在定义属性和方法，属性和行为共同成为类中的成员（成员变量和成员方法）。

类中不必有主函数，不必保证独立运行,只有保证有一个主函数入口调用类就行。

成员变量和局部变量的区别。

作用范围。

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

局部变量变量作用于函数中，或者语句中。

在内存中的位置：

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

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

*/

成员变量：

• 成员变量定义在类中，在整个类中都可以被访问。

• 成员变量随着对象的建立而建立，存在于对象所在的堆内存中。

• 成员变量有默认初始化值。

局部变量：

• 局部变量只定义在局部范围内，如：函数内，语句内等。

• 局部变量存在于栈内存中。

• 作用的范围结束，变量空间会自动释放。

• 局部变量没有默认初始化值。

面向对象在内存中的结构

public class _02Car对象 {
	
	public static void main(String[] args) 
	{
		//生产汽车就是在Java中通过new操作符来完成
		//其实就是在堆内存中产生一个实体
		Car c = new Car();
		c.color="Blue";
		c.run();
	}
}
//创建对象
class Car
{
	//定义成员变量
	String color = "red";
	int num = 4;
	
	//定义对象方法
	void run()
	{
		System.out.print("车是"+color+"色的，有"+num+"个车胎");
	}
}

匿名对象，没有名字的对象。

new Car();//匿名对象。其实就是对象的简写格式。

1、当对象对方法仅进行一次调用的时候，就可以简化成匿名对象。

2、匿名对象可以作为实际参数进行传递。

注意:调用匿名对象的属性是没有意义。

封装

封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

好处：
• 将变化隔离。
• 便于使用。
• 提高重用性。
• 提高安全性。

封装原则：
• 将不需要对外提供的内容都隐藏起来。
• 把属性都隐藏，提供公共方法对其访问。

举例：键盘：

我们只要会使用键盘上的键，敲出我们需要的文字就可以了，至于键盘里面是什么构造，怎么实现我们敲出字来，这个我们就不用思考了，

简称：封装

private(私有)关键字

 private关键字：

• 是一个权限修饰符。

• 用于修饰成员(成员变量和成员函数)

• 被私有化的成员只在本类中有效。

 常用之一：

• 将成员变量私有化，对外提供对应的set，get方法对其进行访问。提高对数据访问的安全性。

Ｐriva解析图

/*
 * Private：私有权限修饰符。用于修饰类中的成员（成员变量，成员函数）
 * 私有只在本类中有效
 * 
 * 将age成员私有化后，类以外即使建立了对象，也不能直接访问
 * 但人该有年龄，就需要在Person类中提供对应访问的age变量
 * 
 * 注意：私有仅仅是封装的一种表现形式
 *       之所以对外提供访问方式，就是因为可以在访问方式中加入逻辑判断语句，对访问数据操作
 *       提高代码的健壮性。
 */
class Person
{
	//年龄
	private int age;//私有变量
	//赋值
	public void setAge(int x)//setAge没有返回值，而且要进行传参
	{
		if(x>0 && x<130)
		{
			age = x;
			Speak();//判断成功，输出
		}
		else
		{
			System.out.print("输入有误，重新输入！"); 
		}
	}
	//取值
	public int getAge()
	{
		return age;
	}
	//人的语言功能
	void Speak()
	{
		System.out.print("我今年"+age+"岁了");
	}
}
public class _04封装Private {
	
	public static void main(String[] args)
	{
		Person p = new Person();
		p.setAge(222);//传值
		
	}

}

构造函数：

构造函数特点：

1、函数名与类名相同。

2、不用定义返回值类型。

3、没有具体的返回值。

构造函数：构建创造对象时调用的函数。

构造函数作用：给对象进行初始化。

创建对象都必须要通过构造函数初始化。

一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参数构造函数。

如果在类中定义了指定的构造函数，那么类中的默认构造函数就没有了。

注意：

1、默认构造函数的特点。

2、多个构造函数是以重载的形式在在的。

一般函数和构造函数什么区别呢？

构造函数：对象创建时，就会调用与之对应的构造函数，给对象进行默认初始化。

一般函数：对象创建后，需要函数功能时才调用。(函数只有被调用才执行)

构造函数：对象创建时，只调用一次。

一般函数：对象创建后，可以被调用多次。

什么时候定义构造函数呢？

在描述事物时，该事物已存在就具备一些内容，这些内容都定义在构造函数中。

构造函数可以有多个，用于对不同的对象进行针对性的初始化。

多个构造函数在类中是以重载的形式来体现的。

构造函数的小细节：

当一个类中没有定义构造函数时，系统会默认给该类加入一个空参数的构造函数Person(){}

当在类中自定义了构造函数后，默认的构造函数就没有了

//下面定义“构造函数”
class PersonOne
{
	//定义私有成员变量
	private String name;
	private int age;
	
	//定义构造函数
	PersonOne()            //始初化函数
	{
		System.out.println("姓名="+name+",年龄="+age);
	}
	
	PersonOne(String a)
	{
		name = a;
		System.out.println("姓名="+name+",年龄="+age);
		Say();//调用功能
	}
	
	//Get Set 什么时候用？例如：想改孩子出生时的名字时
	public void setName(String x)
	{
		name = x;
	}
	public String getName()//这个带返回值
	{
		return name;
	}
	PersonOne(String a,int b)
	{
		name = a;
		age = b;
		System.out.println("姓名="+name+",年龄="+age);
		Say();//调用功能
	}
	//下面定义功能
	void Say()
	{
		System.out.println("cry");
	}
}
public class _05面向对象_构造函数 
{

	public static void main(String[] args)
	{
	PersonOne p1 = new PersonOne();
	PersonOne p2 = new PersonOne("张三");
	PersonOne p3 = new PersonOne("李四",22);
	}
}

this：关键字

特点：this代表其所在函数所属对象的引用。

换言之：this代本类对象的引用。

什么时候使用this关键字呢？

当在函数内需要用到调用该函数的对象时，就用this。

当成员变量和局部变量重名，可以用关键字this来区分。

this：代表对象。代表哪个对象呢？当前对象。

this：就是所在函数所属对象的引用。

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

/*
 * this 它所在函数所属对象的引用
 * 白话说：哪个函数在调用this所在的函数，this就代表哪个对象
 */
class PersonThree
{
	private String name;
	private int age;
	
	PersonThree()
	{
		System.out.println("名字："+this.name+"，年龄是："+this.age);
	}
	PersonThree(String name)
	{
		this.name = name;
		System.out.println("名字："+this.name+"，年龄是："+this.age);
	}
	PersonThree(String name,int age)
	{
		this.name = name;
		this.age = age;
		System.out.println("名字："+this.name+"，年龄是："+this.age);
		this.Say();//也可以加this
	}
	public void setName(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return name;
	}
	public void Say()
	{
		System.out.print("说话功能");
	}
}
public class _07this关键字 {
	
	public static void main(String[] args)
	{
		PersonThree p = new PersonThree("zhangsan");
		PersonThree p1 = new PersonThree("lisi",22);
		
	}

}

this在构造函数中的应用

/*
 * this语句   用于构造函数之间，相互调用
 * this语句只能定义在构造函数的第一行，因为初始化要先执行。
 */
class PersonFor
{
	private String name;
	private int age;
	
	PersonFor()
	{
		this("haha");
	}
	PersonFor(String name)
	{
		this.name=name;
	}
	PersonFor(String name,int age)
	{
		this(name);
		this.age=age;
	}
	void print()
	{
		System.out.println("名字："+name+"年龄："+age);
	}
}
public class _08this在构造函数中的调用 {

	public static void main(String[] args)
	{
		PersonFor p1 = new PersonFor();
		PersonFor p2 = new PersonFor("张三",22);
		p1.print();
		p2.print();
	}
}

静态Static

静态Static 什么时候使用？
/*
静态修饰的内容可以被对象共享。
静态的好处？可以节省内存空间，不用每个对象都去创建一份相同的引用。例如：国家。
 * 什么时候使用静态？
 * 
 * 要从两方面下手：
 * 因为静态修饰的内容有成员变量和函数。
 * 什么时候定义静态变量呢？
 * 当对象中出现共享数据时，（例如：同属一个国家：中国）该数据被静态所修饰。
 * 对象中特有的数据要定义成非静态存在于堆内存中。
 * 
 * 什么时候定义静态函数呢？
 * 当功能内部没有访问到非静态数据时，（对象的特有数据）
 * 那么该功能可以定义成静态的。
 */
class Person
{
	String name;
	
	//直接调用方法功能
	public static void Show()
	{
		System.out.println("haha");
	}
}
public class _03静态Static什么时候用 {
	
	public static void main(String[]args)
	{
		//创建对象的方式   调用方法
		Person P = new Person();
		P.Show();
		
		//不创建对象的方式调用
		Person.Show();//无需new一个对象，直接调用静态方法功能（这样可以节省内存）
	}

}

静态代码块

/*
 * 静态代码块：格式
 * static
 * {
 * 		静态代码块的执行语句
 * }
 * 
 * 静态代码块特点：随着类的加载而加载。只执行一次。（并优先于主函数执行）
 * 白话是：程序一执行起来，先对静态代码块执行，所有的静态代码块执行完成后，再执行主函数
 * 对类进行初始化。
 */
class StaticCode
{
	/*小知识点：
	int num=9;
	static
	{
		System.out.println("后面不能加gum，因为静态成员只能访问静态变量！"+num);
	}
	*/
	static
	{
		System.out.println("a.静态代码块特点：随着类的加载而加载。只执行一次。并优先于主函数执行");
	}
	{
		System.out.println("e..构造代码块，给对象初始化的。");
	}
	StaticCode(int x)
	{
		System.out.println("f..构造函数，给对应对象初始化的");
	}                 //这个后面可以加上面的num;因为它是对象的初始化，所以可以访问成员变量
}
public class _05静态代码块 {
	
	static 
	{
		System.out.println("b..对类进行初始化。");
	}

	public static void main(String[]args)
	{
		///new StaticCode();
		//new StaticCode();   //new两个对象，但在程序中只执行了一次。
		
		new StaticCode(4);//进行传递参数
		System.out.println("over");
	}
	static
	{
		System.out.println("c");
	}
}
/*
 * 上面代码的执行顺序是：
 *	b..对类进行初始化。
	c
	a.静态代码块特点：随着类的加载而加载。只执行一次。并优先于主函数执行
	e..构造代码块，给对象初始化的。
	f..构造函数，给对应对象初始化的
	over
 */

---------------------- 黑马程序员 Android培训、期待与您交流！ ----------------------

路漫漫求索

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员 ——面向对象

---------------------- 黑马程序员 Android培训、期待与您交流！ -------------------------------------------- 黑马程序员 Android培训、期待与您交流！ ----------------------
复制链接

扫一扫

专栏目录