黑马程序员-----JAVA面向对象

----------------------ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

1.面向过程和面向对象

面向过程是一种以事件为中心的编程思想，以功能行为为导向，按模块化的设计。我通俗理解就是分析出解决问题所需要的步

骤，然后用函数把这些步骤一步一步实现，使用的时候再一个一个依次调用即可。

面向对象是一种以事物为中心的编程思想，以属性为导向。将具有相同的一个或者多个属性的物体抽象为“类”，将它们封装起

来，建立对象的目的不是像面向过程那样为了完成一个步骤，而是为了描述某个事物在整个解决问题的步骤中的行为。

例如将大象装进冰箱里这个需求来说，对于面向过程强调的是功能行为，它就是按顺序的执行打开冰箱，将大象存储进冰箱，

关闭冰箱这三个步骤。而对于面向对象是将功能封装进对象，强调具备了功能的对象，冰箱具备了打开，存储，关闭这三个功能。将大象装进冰箱只用调用冰箱的这三个功能即可。

面向对象就是将复杂问题简单化，从执行者到指挥者的转变。

2.类与对象的关系

对象就是现实生活中实实在在存在的个体，具有明确定义的属性和行为。

类是对现实生活中事物的描述，是对象抽象出来的类别模板，是具有相同特征和共同行为的一组对象的集合。

描述是用类来体现的，实体是对象来体现的。映射到JAVA中就是，描述是Class定义的类，具体对象是对应JAVA在堆内存中

用new建立实体。

　　//事例：建立一个汽车类，并实例化对象。
　　class Car
　　{
　　	//描述颜色
　　	String color = "红色";
　　	//描述轮胎数
　　	int num = 4;
　　
　　	//运行行为
　　	void run()
　　	{
　　		System.out.println(color+".."+num);
　　	}
　　}
　　class carDemo
　　{
　　	public static void main(String[] args) 
　　	{
　　		//生产汽车，java中通过new操作来完成
　　		//其实就是在堆内存中产生一个实体。
　　		Car c = new Car();//c就是类类型变量。注：类类型变量指向对象。
　　
　　		//需求：将已有的车的颜色改成蓝色。在java中指挥方式是：对象.对象成员。
　　		c.color = "蓝色";
　　		c.run();
　　
　　		Car c1 = new Car();
　　		c1.run();
　　	}
　　}

3.成员变量和局部变量的差异

作用范围不同，成员变量作用于整个类中，局部变量作用于函数或语句中。

在内存中的存储位置不同，成员变量存在于堆内存中，因为对象的存在而存在，局部变量存在于栈内存中。

4.构造函数和构造代码块

构造函数特点：函数名和类名一致，不用定义返回值类型，不可以写return语句。

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

构造函数在对象一建立就运行了，用于给对象初始化，当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参

数的构造函数。方便该类进行初始化。当在类中自定义了构造函数后，默认的构造函数就没有了。

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

构造代码块是定义不同对象共性的初始化内容，在对象一建立就运行了。而且优先于构造函数的运行。构造代码块是给所有对

象进行统一初始化的，而构造函数时给对应的对象进行初始化的。

5.this关键字

代表着本类的对象，它所在的函数所属对象的引用。

哪个对象在调用this所在的函数，this就代表哪个对象。

当定义类中功能（函数）时，该函数内部要用，调用该函数的对象时，这时用this来表示这个对象。

构造函数中调用只能用this语句。This语句只能构造在构造函数中的第一行，因为初始化要先执行。

　　事例：
　　class Person
　　{
　　	private String name;
　　	private int age;
　　	
　　	Person(int age)
　　	{
　　		this.age = age;
　　	}
　　	
　　	Person(String name)
　　	{
　　		this.name = name;
　　	}
　　
　　	Person(String name,int age)
　　	{
　　		this.name = name;
　　		this.age = age;
　　	}
　　
　　	public void speak()
　　	{
　　		System.out.println("name="+this.name+",,age="+this.age);
　　		this.show();
　　	}
　　	public void show()
　　	{
　　		System.out.println(this.name);
　　	}
　　}
　　class  PersonDemo3
　　{
　　	public static void main(String[] args) 
　　	{
　　		Person p1 = new Person(20);
　　		Person p2 = new Person(21);
　　		Person p = new Person("lisi");//lisi已经赋值到了构造函数中的参数，但是没有赋值给堆内存中的对象。
　　		Person p1 = new Person("zhangsan");
　　		p.speak();
　　		p1.speak();
　　	}
　　}

6.static关键字

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

类名 . 静态成员

特点：随着类的加载而加载。优先于对象存在，被所有的对象共享，能直接被类名调用。

注意事项：静态方法只能访问静态成员，静态方法中不可以定义this，super关键字。因为静态优先于对象存在。

　　事例：
　　class Person
　　{
　　	String name;//成员变量，实例变量。
　　	static String country = "CN";//静态成员变量，类变量。
　　	public void show()
　　	{
　　		System.out.println(name+"::::"+country);
　　	}
　　}
　　class StaticDemo 
　　{
　　	public static void main(String[] args) 
　　	{
　　		Person p = new Person();
　　		p.show();
　　	}
　　}

静态代码块随着类的加载而执行，只执行一次，并优先于主函数，用于给类进行初始化。

格式：

static

{

静态代码块的执行语句

}

7.final关键字

是一个修饰符，可以修饰类，函数，变量。被final修饰的类不可以被继承，被final修饰的方法不能被复写，被final修饰的变量时

一个常量只能赋值一次，既可以修饰成员变量，又可以修饰局部变量，内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。

8.面向对象的三大特性

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

封装：隐藏对象的属性和实现细节。仅对外提供公共访问方式。好处是将变化隔离，便于使用，提高重用性，提高安全性。原

则是讲不需要对外提供的内容都隐藏，把属性都隐藏只提供公共方法对其访问。

Private：私有，权限修饰符；用于修饰类中的成员（成员变量，成员函数），私有仅在本类中有效。将成员私有化之后，类

以外即使建立了对象也不能直接访问。为了访问在本类中提供对应的 get 和 set 方法。之所以对外提供访问方式，就是因为可以在访问方式中加入逻辑判断等语句。对访问的数据进行操作，提高代码的健壮性。

注意：私有仅仅是封装的一种表现形式。

　　事例：
　　class Person
　　{
　　	private int age;
　　
　　	public void setAge(int a)
　　	{
　　		if(a>0 && a<130)
　　		{
　　			age = a;
　　			speak();
　　		}
　　		else
　　			System.out.println("年龄非法");
　　	}
　　
　　	public int getAge()
　　	{
　　		return age;
　　	}
　　	void speak()
　　	{
　　		System.out.println("age="+age);
　　	}
　　}
　　
　　class PersonDemo
　　{
　　	public static void main(String[] args) 
　　	{
　　		Person p = new Person();
　　
　　		//p.age = 20;
　　		p.setAge(-20);
　　	}
　　}

继承：是指一种能力：它可以使用现有类的所有功能，并在无需更新编写原来类的情况下对这些功能进行扩展。继承提高了代

码的复用性，让类和类之间产生了关系，有了这个关系，才有了多态的特征。

Java语言中只支持单继承，不支持多继承。因为多继承容易带来安全隐患。当多个父类中定义了相同功能，当功能相同时，子

类对象不确定要运行哪一个。但是java保留了这种机制，并用另一种体现形式来完成标示：多实现。

　　事例：
　　class Person
　　{
　　	String name;
　　	int age;
　　}
　　
　　class Student extends Person
　　{
　　	void study()
　　	{
　　		System.out.println("good study!");
　　	}
　　}
　　
　　class Worker extends Person
　　{
　　	void work()
　　	{
　　		System.out.println("good work!");
　　	}
　　}
　　class ExtendsDemo 
　　{
　　	public static void main(String[] args) 
　　	{
　　		Student s = new Student();
　　		s.name = "zhangsan";
　　	}
　　}

Abstract：用关键字abstract修饰的类称为抽象类。抽象类的特点，抽象方法一定定义在抽象类中，抽象方法和抽象类都必须

被 abstract 关键字修饰，抽象类不可以用 new 创建对象，因为调用抽象方法没意义，抽象类中的方法要被使用，必须由子类复写其所有的抽象方法后，建立子类对象调用，如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。

特殊：抽象类中可以不定义抽象方法。这样做仅仅是不让该类建立对象

　　事例：
　　abstract class Student
　　{
　　	abstract void study();
　　}
　　class BaseStudent extends Student
　　{
　　	void study()
　　	{
　　		System.out.println("base study");
　　	}
　　}
　　
　　class AdvStudent extends Student
　　{
　　	void study()
　　	{
　　		System.out.println("adv study");
　　	}
　　}
　　class AbstractDemo 
　　{
　　	public static void main(String[] args) 
　　	{
　　		System.out.println("Hello World!");
　　	}
　　}

Interface：接口：初期理解，可以认为是一个特殊的抽象类，当抽象类中的方法都是抽象的，那么该类可以通过接口的形式

来表示。接口中的成员都是public，接口：是不可以创建对象，因为有抽象方法。需要被子类实现implements，子类对接口中的抽象方法全部覆盖后，子类才可以实例化，否则子类是一个抽象类。接口可以被类多实现。也是对多继承不支持的转换形式。一个类可以实现多个接口。java支持多实现。

　　事例：
　　interface Inter
　　{
　　	public static final int NUM = 3;
　　	public abstract void show();
　　}
　　
　　interface InterA
　　{
　　	public abstract void method();
　　}
　　
　　class Demo
　　{
　　	public void function(){}
　　}
　　
　　class Test extends Demo implements Inter,InterA
　　{
　　	public void show(){}
　　	public void method(){}
　　}
　　
　　interface A
　　{
　　	void methodA();
　　}
　　
　　interface B extends A
　　{
　　	void methodB();
　　}
　　
　　interface C extends B,A
　　{
　　	void methodC();
　　}
　　
　　class D implements C
　　{
　　	public void methodA(){}
　　	public void methodB(){}
　　	public void methodC(){}
　　}
　　
　　class InterFaceDemo 
　　{
　　	public static void main(String[] args) 
　　	{
　　		Test t = new Test();
　　		System.out.println(t.NUM);
　　		System.out.println(Test.NUM);
　　		System.out.println(Inter.NUM);
　　	}
　　}

多态：可以理解为事物存在的多种体现形态。多态的体现，父类的引用指向了自己的子类对象，父类的引用也可以接收自己的

子类对象。多态的前提，必须是类和类之间有关系，要么继承，要么实现，通常还有一个前提，存在覆盖。多态的好处，多态的出现大大提高了程序的扩展性。多态的弊端，提高了扩展性，但是只能使用父类的引用访问父类中的成员。

----------------------ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------