黑马程序员—Java面向对象

原创 2015年07月07日 13:49:40

3.面向对象

 

3.1面向对象的概念

 

面向对象是相对于面向过程而言

特点:1:将复杂的事情简单化。

    2:面向对象将以前的过程中的执行者,变成了指挥者。

    3:面向对象这种思想是符合现在人们思考习惯的一种思想。


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

面向对象:将功能封装进对象,强调具备了功能的对象

过程其实就是函数;对象是将函数等一些内容进行了封装。

 

面向对象的特征:封装,继承,多态。

 

类和对象的关系:

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

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

 

成员变量和局部变量:

成员变量作用于整个类中,局部变量作用于函数中或者语句中。

成员变量在堆内存中,因为对象的存在才在内存中存在;局部变量存在于栈内存中,随着所属区域的运行而存在,结束而释放。

 

匿名对象使用方式:

1)当对对象的方法值调用一次时,可以用匿名对象来完成,这样写比较简化。

当对一个对象进行多个成员调用,必须给这个对象起个名字

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

 

 

3.2 封装

 

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

好处:将变化隔离;便于使用;提高重用性;安全性。

封装原则:将不需要对外提供的内容都隐藏起来,把属性都隐藏,提供公共方法对其访问。


权限修饰符:

private:用于修饰类中的成员(成员变量,成员函数),只在本类中有效。是封装的一种形式。

私有的成员:其他类不能直接创建对象访问,所以只有通过本类对外提供具体的访问方式来完成对私有的访问,可以通过对外提供函数的形式对其进行访问。

好处:可以在函数中加入逻辑判断等操作,对数据进行判断等操作。



3.3 构造函数


构造函数:用于给对象进行初始化,是给与之对应的对象进行初始化,它具有针对性,函数中的一种。

特点:

1:该函数的名称和所在类的名称相同。

2:不需要定义返回值类型。

3:该函数没有具体的返回值。

 

对象一建立就会调用与之对应的构造函数。

构造函数的作用:可以用于给对象进行初始化。当一个类中没有定义构造函数时,那么系统会默认给该类加入一个空参数的构造函数。

 

一个类中,可以有多个构造函数,因为它们的函数名称都相同,所以只能通过参数列表来区分。所以,一个类中如果出现多个构造函数。它们的存在是以重载体现的。

 

构造函数与一般方法的区别:

在写法上有不同。

在运行上不同。构造函数时在对象一建立就运行,给对象初始化;一般方法是对象调用才执行,给对象添加对象具备的功能。

一个对象建立,构造函数只运行一次;而一般方法可以被对象多次调用。



3.3 构造代码块

 

作用:给对象进行初始化。对象一建立就运行,而且优先于构造函数执行

 

构造代码块和构造函数的区别:

构造代码块:是给所有对象进行统一的初始化,也就是说,所有的对象都会调用一个代码块。只要对象一建立。就会调用这个代码块。

构造函数:是给对应的对象初始化。它具有针对性

 

构造代码块中定义的是不同对象共性的初始化内容。



3.4 this关键字

 

this代表它所在函数所属对象的引用。即哪个对象在调用this所在的函数,this就代表哪个对象

 

调用格式:

this对象后面跟上 .  调用的是成员属性和成员方法(一般方法);

this对象后面跟上 () 调用的是本类中的对应参数的构造函数。

 

this语句可用于构造函数之间互相调用,构造函数间调用只能用this 语句。

用this调用构造函数,必须定义在构造函数的第一行。因为构造函数是用于初始化的,所以初始化动作一定要执行。否则编译失败。


应用实例:

class  Person
{	
	private String name;
	private int age;
	private static String country = "cn";       //存在于方法区内存

	Person(String name)                         //构造函数1
	{	
		this.name = name;
	}

	Person(String name,int age)                 //构造函数2
	{
		this (name);
		this.age = age;
	}

	public void speak()
	{
		System.out.println(this.name+"..."+this.age);
	}

	public static void showCountry()
	{
		System.out.println("country="+country);
	}
}

class PersonDemo
{                                                  
	public static void main(String[] args)    
	{       /*
		 定义一个对象Person,先调用构造函数2,执行this(name)语句,即p(name);此时会调用构造函数1,
                 随即对private的name进行赋值,再跳回构造函数2中执行this.age=age语句,即对private的age进行赋值
		*/
		Person p = new Person("lisi",30);    
	}                                  
}



3.4 static关键字

 

static  静态关键字。是一个修饰符,用于修饰成员(成员变量,成员函数),静态修饰内容被对象所共享。静态修饰内容储存在数据区(方法区,共享区),是对象中共性的部分。

 

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

 

static特点:

1) 随着类的加载而加载。 //也就是说静态会随着类的消失而消失,说明它的生命周期最长

2) 优先于对象存在      //静态是先存在的,对象是后存在的

3) 被所有对象所共享

4) 可以直接被类名所调用

 

成员变量和静态变量的区别:

1)成员变量所属于对象。所以也称为实例变量。

静态变量所属于类。所以也称为类变量。

2) 存放位置

类变量随着类的加载而存在于方法区中。实例变量随着对象的建立而存在于堆内存中。

3) 生命周期

类变量生命周期最长,随着类的加载而存在,随着类的消失而消失。实例变量随着对象创建而存在,随着对象的消失而消失。

4)成员变量只能被对象所调用。静态变量可以被对象调用,也可以被类名调用。

 

静态使用注意事项:

1) 有些数据是对象特有的数据,是不可以被静态修饰的。因为那样的话,特有数据会变成对象的共享数据。这样对事物的描述就出了问题。所以,在定义静态时,必须要明确,这个数据是否是被对象所共享的。

2) 静态方法只能访问静态成员,因为静态方法加载时,优先于对象存在,所以没有办法访

问对象中的成员。

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

2)静态方法中不可以定义this,super关键字

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

3)主函数是静态的

 

静态有利有弊

利:对对象的共享数据进行单独空间的存储,节省空间。

可以直接被类名调用

弊端:

生命周期过长。访问出现局限性(只能访问静态)

 

 

静态的使用:

当对象中出现共享数据时,即该成员变量的数据是所有对象都一样,则该数据被静态所修饰。对象中的特有数据要定义成非静态,存在于堆内存中。

当方法内部没有访问到非静态数据(对象的特有数据),那么该方法可以定义成静态。

 

静态的应用:

将类中的程序都定义成static,就可以不创建对象,直接通过类名调用

通过将构造函数私有化(private ArrayTool(){})(自定义的空参数构造函数),可以强制让该类不能建立对象,但可以通过类名来调用其中的程序。

 

一个类中默认会有一个空参数的构造函数,这个默认的构造函数的权限和所属类一致。如果类被public修饰,那么默认的构造函数也带public修饰符;如果类没有被public修饰,那么默认的构造函数也没有public修饰符。

 

主函数:

public static void main(String[] args)

是一个特殊的函数,作为程序的入口,可以被jvm调用。

主函数的定义:

public:代表着该函数访问权限是最大的

static:代表主函数随着类的加载就已经存在了

void:主函数没有具体的返回值

main:不是关键字,但是是一个特殊的单词,可以被jvm识别

(String[] args):函数的参数,参数类型是一个数组,该数组中的元素是字符串,字符串类型的数组

 

主函数是固定格式的:jvm识别

jvm在调用主函数时,默认传入的是newString[0](没有参数的字符串数组);我们在运行该类时,也可以指定具体的参数进行传递。可以在控制台,运行该类时,在后面加入参数。参数之间通过空格隔开。jvm会自动将这些字符串参数作为args数组中的元素,进行存储。

 

 

静态代码块:

就是一个有静态关键字标示的一个代码块区域。定义在类中。

static

{

         静态代码块中的执行语句。

}

特点:随着类的加载而执行,只执行一次,并优先于主函数

用于给类进行初始化的。


静态代码块演示示例:

class StaticCode
{
	static                               
	{
		System.out.println("a");
	}
}

class StaticCodeDemo
{
	static
	{
		System.out.println("b");                //加载时便执行
	}
	public static void main(String[] args) 
	{
		new StaticCode();                      //加载类进内存,执行操作
		new StaticCode();                      //不执行,因为类已经在内存中,不会再
		System.out.println("over");            //加载静态代码块
	}
	static                                         //优先于主函数执行,第二个执行
	{
		System.out.println("c");
	}
}
//输出结果为b c a over

静态代码块优先于构造代码块优先于构造函数

 

创建一个对象都在内存中做了什么事情:

1) 因为new用到了Person.class。所以会先从硬盘中找到Person.class文件并加载到内存中

2) 在静态区执行该类中的static代码块(如果有的话),给Person.class类进行初始化。

3) 执行main方法时,在栈内存中开辟了main方法的空间(压栈-进栈),然后在main方法的栈区分配了一个变量p。

4) 在堆内存中开辟空间,分配内存地址

5) 在堆内存中进行属性的空间分配,并进行默认初始化

6) 对空间中的属性进行显示初始化

7) 对对象进行构造代码块初始化

8) 对对象进行对应的构造函数初始化

9) 将内存地址赋给栈内存中的p变量



3.5 设计模式

 

解决某一类问题最行之有效的方法。是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。java中有23种设计模式。

 

单例设计模式:解决一个类在内存中只存在一个对象

 

想要保住对象唯一:

1) 为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象

2) 还为了让其他程序可以访问到该类对象,只好在本类中自定义一个对象

3) 为了方便其他程序对自定义对象的访问,可以对外提供一些访问方式

 

步骤:

1) 将构造函数私有化

2) 在类中创建一个本类对象

3) 提供一个方法可以获取到该对象

 

代码体现:

1)私有化构造函数;

2)创建私有并静态的本类对象;

3)定义公有并静态的方法,返回该对象。


先初始化对象(饿汉式):Single类一进内存,就已经创建好了对象。

class Single
{
	private Single(){}

	private static Single s = new Single();      

	public static Single getInstance()
	{
		return s;
	}
}

对象是方法被调用时才初始化(对象的延时加载—懒汉式):

Singles类进内存,对象还没有存在,只有调用了getInstance方法时,才建立对象。

class Single                           
{
	private static Single s = null;
	private Single(){}
	public static Single getInstance()     当多个程序同时调用此方法时,可能会出错
	{
		if(s==null)
			s = new Single();          
		return s;
	}
}



相关文章推荐

黑马程序员—4、JAVA基础&面向对象

黑马程序员—4、JAVA基础&面向对象   --------------------- android培训、java培训、期待与您交流! ---------------------- 面向对象的...

黑马程序员—java面向对象一

---------------------- android培训、java培训、期待与您交流! ---------------------- 一、面向对象的概念 (一)面向对象与面向过程 面向对...

黑马程序员—Java入门学习日记基础篇-面向对象总结1

Java面向对象编程知识点总结。 一:单例设计模式。 何为单例设计模式,单例设计模式是指为解决一个类在内存中只有一个对象,保证对象唯一的一种设计方法。 单例设计模式的的设计规则如下: 为避...

黑马程序员—java面向对象总结(1)

面向对象概念: 1、面向对象:将功能封装进对象,强调具备了功能的对象,面向对象是基于面向过程的; 2、面向对象三大特征:封装、继承,多态; 3、面向对象会用到两个概念:类与对象;类是对现实...

黑马程序员_JAVA笔记09—面向对象5(内部类、异常)

------- android培训、java培训、期待与您交流! ---------- 1、内部类         访问规则:                 内部类可以直接访问外部...

黑马程序员—【Java基础篇】之面向对象

------- android培训、java培训、期待与您交流! ---------     这篇分享和总结Java之面对对象。     主要学习型内容有:1.面向对象概念;2. 类与对象的关系;3...
  • WL8721
  • WL8721
  • 2015年04月21日 10:40
  • 411

黑马程序员————java面向对象学习

---------------------- android培训、java培训、期待与您交流! ---------------------- java面向对象的三大特征:封装,继承,多态。 面...

黑马程序员—Java面向对象(异常处理机制、package包、import导入包、jar包)

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

黑马程序员—4—Java基础: 面向对象继承学习笔记和学习心得体会

1.       继承概述   1.提高啦嗲吗的复用性。   2.让类与类之间产生啦关系,有了这个关系,才有了多态的特性。   注意:千万不要为了获取其它类的功能,简化代码而继承         必须...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:黑马程序员—Java面向对象
举报原因:
原因补充:

(最多只允许输入30个字)