黑马程序员_java面向对象

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

面向对象概念

面向对象是相对面向过程而言，面向对象和面向过程都是一种思想。

面向过程强调的是功能行为，面向对象是将功能封装进对象，强调具备了功能的对象。

C语言是面向过程，java是面向对象的一门计算机语言。

面向对象设计把握一个重要的经验：谁拥有数据，谁就对外提供操作这些数据的方法。

例如：

①人在黑板上画圆。有person、blackboard、circle三个对象，应该把画圆这个方法放置在哪个对象里面呢?画圆涉及到圆的圆心和半径，这些属性都是属于圆本身的，所以我们在设计的时候应该把画圆的方法放置在圆对象中。

②“两块石头磨成一把石刀，石刀可以砍树，砍成木材，木材做成椅子”

StoneKnife = KnifeFactory.createKnife(stone)

material = StoneKnife.cut(tree)

Chair = ChairFactory.makeChair(material)

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

类与对象的关系

类是对现实生活中事物的描述；对象是这类事物实实在在存在的个体。

现实生活中的对象：张三 李四

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

描述时：这些对象的共性内容有姓名、年龄、性别等属性。

映射到java中，描述就是class定义的类。具体对象就是对应java在堆内存中用new建立的实体。

封装

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

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

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

例：

public class Person 
{
	private String name;
	private int age;
	public void shout()
	{
		System.out.println("name = " + name + ",age = " + age);
	}
	
	//为私有属性age加上setter和getter方法，并在setter方法处加上合理的检测代码。
	public int getAge() 
	{
		return age;
	}
	public void setAge(int age) 
	{
		if(age > 0 && age <120)
		this.age = age;
	}	
}

构造函数

特点：

1.函数名与类名相同；

2.不用定义返回值类型；

3.不可以写return语句。

作用：

给对象进行初始化。对象一建立，便会调用相应参数的构造函数。

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

构造函数和一般函数的区别：

写法上不同；

运行上也不同，构造函数在对象一建立便开始运行，负责给对象初始化。而一般方法是在对象调用时才执行。

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

例：

public class Person 
{
	private String name;
	private int age;
	
	//定义无参构造方法
	public Person()
	{		
	}
	//定义有参构造方法，并进行赋值。
	public Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	
	public void shout()
	{
		System.out.println("name = " + name + ",age = " + age);
	}
	
	public static void main(String[] args)
	{
		Person p = new Person("zhangsan",20);
		p.shout();
	}
}

单例设计模式

饿汉式：

class Single 
{	
	private static Single single = new Single();
	private Single()
	{
	}
	public static Single getInstance()
	{
		return single;
	}
}

懒汉式：

class Single 
{
	private static Single single = null;
	private Single()
	{
	}
	public static Single getInstance()
	{
		//判断是否已经有该类的实例对象存在。如果有，直接返回该实例对象；如果没有，再进行封锁创建。
		if(single==null)
		{
		    //封锁操作。保证只有一个线程能够访问该代码块，进而保证只创建一个实例对象。
			synchronized(Single.class)
		    {
		    	if(single==null)
		    		single=new Single();
		    }
		}		  
		return single;
	}
}

两者的区别在于饿汉式是在类加载进计算机内存的时候便开始创建实例对象，懒汉式是在需要的时候人为的去创建实例对象。

继承

提高了代码的复用性，让类与类之间产生了关系，有了这个关系，才有了多态的特性。

但千万不要为了获取其他类的功能，简化代码而继承；必须是类与类之间有所属关系才可以继承。

父类的由来是从子类不断向上抽取而来。

java语言中只支持单继承，不支持多继承。因为多继承容易带来安全隐患：当多个父类中定义了相同功能，当功能内容不同时，子类对象不确定要运行哪一个。但java中支持多层继承，也就是一个继承体系。

如何使用一个继承体系中的功能呢?

想要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中共性功能，通过了解共性功能，就可以知道该体系的基本功能。

在具体调用时，要创建最子类的对象。一是因为有可能父类是抽象类，二是创建子类对象可以使用更多的功能，包括父类中的基本功能和自身所特有的功能。

子类继承父类中非私有的属性、方法，但不能继承父类中的构造函数。

综合案例：将类中的属性都私有化，并进行继承操作。

class Person 
{
	private String name;
	private int 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;
	}
	
	public Person()
	{		
	}
	public Person(String name,int age)
	{
		setName(name);
		setAge(age);
	}
	
	public void shout()
	{
		System.out.println("name = " + name + ",age = " + age);
	}
}

class Student extends Person
{
	private String school;
	public String getSchool() 
	{
		return school;
	}
	public void setSchool(String school) 
	{
		this.school = school;
	}
	
	public Student()
	{		
	}
	public Student(String name,int age)
	{
		super(name,age);//调用父类中含有两个参数的构造方法
	}
	public Student(String name,int age,String school)
	{
		this(name,age);//调用本类中含有两个参数的构造方法
		setSchool(school);
	}
	//对父类中的shout()方法进行重写
	public void shout()
	{
		System.out.println("name = " + getName() + ",age = " + getAge() + ",school = " + school);
	}
}

class TestStudent
{
	public static void main(String[] args)
	{
		Student s = new Student("zhangsan",20,"qinghuadaxue");
		s.shout();
	}
}

抽象类与接口

抽象类的特点：

1.抽象方法一定在抽象类中。

2.抽象方法和抽象类都必须被abstract关键字修饰。

3.抽象类不可以创建实例对象，因为调用抽象方法没意义。

4.抽象类中的方法要被使用，必须由子类覆写其所有的抽象方法后，建立子类对象调用。如果子类只覆盖了部分抽象方法，那么该子类仍然是一个抽象类。

接口：

当类中的方法都是抽象的，那么该类可以通过接口的形式来表示。用interface来定义接口。

接口定义时，格式特点：

1.接口中常见定义，常量、抽象方法。

2.接口中的成员都有固定修饰符。常量：public static final，方法：public abstract。

接口是不可以创建对象的，需要被子类实现，子类对接口中的抽象方法全部覆写后，子类才可以实例化，否则子类仍是一个抽象类。

接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。

例：

interface A
{
	public void printA();
}

interface B
{
	public void printB();
}

interface C extends A,B//定义接口C，同时继承接口A、B
{
	public void printC();
}

class U implements C//子类实现接口C，覆写其中所有的抽象方法。
{
	public void printA() 
	{
		System.out.println("A.Hello World");
	}

	public void printB() 
	{
		System.out.println("B.Hello JAVA");
	}

	public void printC() 
	{
		System.out.println("C.Hello Computer");
	}
	
}

public class InterfaceTest 
{
	public static void main(String[] args)
	{
		U u = new U();
		u.printA();
		u.printB();
		u.printC();
	}

}

多态性

可以理解为事物存在的多种体现形态。

1.多态的体现

父类的引用指向了自己的子类对象。

2.多态的前提

必须是类与类之间有关系，要么继承，要么实现。

通常还有一个前提：存在覆盖。

3.多态的好处

多态的出现大大的提高了程序的扩展性。

4.多态的弊端

提高了扩展性，但是只能使用父类的引用访问父类中的成员。

5.多态的应用

abstract class Animal
{
	abstract void eat();
}

class Cat extends Animal
{
	public void eat()//对父类中的抽象方法进行重写
	{
		System.out.println("吃鱼");
	}
	public void catchMouse()
	{
		System.out.println("抓老鼠");
	}
}

class Dog extends Animal
{
	public void eat()
	{
		System.out.println("啃骨头");
	}
	public void housekeeping()
	{
		System.out.println("看家");
	}	
}

public class DuoTaiDemo 
{
	public static void main(String[] args) 
	{
		Animal a = new Cat();//类型提升，向上转型。
		function(a);
		
		Cat c = (Cat)a;//强制将父类的引用转成子类类型，向下转型。
		c.catchMouse();
	}
	public static void function(Animal a)
	{
		a.eat();
	}
}