面向对象(01)

——我是LGM_Hakka，请多多指教。

面向过程与面向对象的区别

1、面向过程

        以函数为基础，强调的是过程。（强调这个方法有什么功能）。

        如：c语言。 

2、面向对象

        面向对象是基于面向过程的，以对象为基础，强调的是结果。（强调对象调用方法能完成怎么样的功能）

面向对象的特点

1、面向对象的特点:

a)  一种更符合人们思考习惯的思想（能懒就懒）

b)  能把复杂的问题简单化

c)  让程序员从执行者转变为指挥者。

2、怎么让自己写的代码更加符合面向对象的思想呢？

   分析步骤

      A：先分析该需求中有什么对象(名词提取法)

      B：明确每个对象可以做什么(动词提取法)

      C：明确每个对象之间的关系

             分析完有哪些对象之后，把每个对象都单独写了一个类。

             每个对象可以做什么就在这个类中定义一个方法.

 

面试：面向对象的例子

阐述三个好处。

举例：其实面试官您就是按照面向对象的思想在思考问题。

面试官您本身就可以开发项目，但是项目有可能比较大，一个人开发周期长。为了提高效率，需要有更多的具备者专业开发能力的人来帮助您做事情。这个人就是您所需的对象，只要调用这些对象的开发功能就可以完成项目。只要指挥他们做事情就可以了。

类与对象

类是什么

   类是属性和行为的集合，是一个抽象的概念。【以下均用Student类举例】

class Student {
	// 定义姓名属性
	String name;
	// 定义方法：学习
	public void study() {
		System.out.println("学生在学习");
	}
}

对象是什么 

    对象是类的具体实现。

   例如：有个学生类Student：

Student lgm = new Student();// lgm就是学生类的一个对象

类与对象之间的关系

    在开发过程中，就是创建很多的类，然后不断的new对象，指挥对象去做某些事情。【对象.方法()】

lgm.study();// 通过对象调用方法

Java语言中最基本的单位是类。

对象的初始化

对象的初始化过程

A：把Student.class文件加载到内存。(类加载器)

B：在栈内开辟一个变量空间。给lgm使用。

C：new Student()就会在堆内存开辟空间。

D：方法进方法区，有类名做标记。并且，同时成员变量进堆内存并给出了默认初始化值。

E：对成员变量进行显示初始化

F：如果有构造代码块，可以在构造代码块中对成员变量赋值。

G：执行构造方法中对成员变量的赋值。

H：到此为止，对象初始化完毕。

I：把堆内存对象的首地址值赋值给栈内存的lgm变量。

匿名对象

1、     匿名对象，就是没有名字的对象。

new Student().study();// 匿名对象，调用方法

2、匿名对象的应用场景：

        A、当对象已经明确只使用一次时，可以将创建匿名对象

【例如：一次性筷子】

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

如何使用类中的内容

1、要使用类中的内容，首先得有对象。

        创建对象的格式：类名 对象名 = new 类名(有/无参数);

2、使用类中的内容，通过该类的对象

        对象调用成员变量、成员方法的格式：          

对象名.成员变量名

对象名.成员方法名(有/无参数);

注意：现在可以在一个文件中写多个类.但是文件名要与带有主方法的那个类名一致。

成员变量与局部变量

1、成员变量

• 成员变量定义在类中方法外
• 成员变量有默认初始值。      

    btye，short，int，long类型的数组，默认初始值是0；

    char类型的数组，默认初始值是'\u'；

    String类型的数组，默认初始值是null；

    boolan 类型的数组，默认初始值是false。

• 存储在堆内存中，因为成员变量是随着对象的存在而存在的，随着对象的消失而消失。

2、局部变量

• 局部变量定义在方法中，或形式参数的位置
• 局部变量是没有默认初始化值的，所以在调用之前必须对其进行赋值操作
• 存储在栈内存中，因为局部变量随着方法的调用而存在，随着方法调用完毕而消失。

 3、使用变量的原则：就近原则

  首先在局部范围找，有就直接使用。

  接着在成员方法找，有就使用。

  最后到父类中成员变量中找，有就使用。（不会到父类的方法中找！）

  如果都没有，就报错。

 

4、那么什么时候需要将变量定义为成员变量呢？

    成员变量是该类的属性。只有能够用于描述该类的属性的变量，才可以定义为该类的成员变量。否则应该定义为局部变量。

构造方法、封装、内部类、匿名内部类

构造方法

1、构造方法的格式：

• 方法名与类名相同
• 没有返回值类型
• 没有具体的返回值

2、作用：给对象初始化；给成员变量赋值

3、给成员变量赋值

• 通过set方法给成员变量赋值(推荐使用set)
• 通过构造方法也可以对成员变量赋值
• set方法它的存在就是为了给成员变量赋值，推荐使用set方法为成员变赋值。
• 构造方法的存在主要目的是初始化对象(它可以捎带脚给成员变量赋值)

4、注意事项

• 如果没有给出构造方法的话,系统会默认给出一个无参构造，建议无参的构造方法手动添加。
• 假如你给出了构造方法,那么系统将不再提供默认构造方法(推荐永远手动给出构造方法)
• 构造方法也可以重载(也就是参数列表不同)

class Student {
	// 定义姓名属性，成员变量
	String name;	
	//无参构造
	public Student(){}
	//带参构造
	public Student(String name) {
		this.name = name;
	}
}

封装

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

2、用private关键字封装仅仅是封装的一种表现形式。因为类与方法等其实也是一种封装的体现。

3、封装的代码体现：

        A、类的成员变量均用private关键字修饰。

        B、若使用默认权限，其权限大小：public权限 < 默认权限 < private权限

        C、要想对数据进行校验，就需要将其封装在方法中。一般不会再主方法进行数据校验。

 4、封装的好处：

• 提高代码的复用性
• 提供成员变量的隐蔽性

5、注意事项

• 当一个类中的成员变量被private关键字修饰时，需要对外提供set和get方法【是用public修饰的成员方法】；
• set和get不一定是成对出现的。若要设置成员变量，那么一定要有set方法；若要获取数据，一定要有get方法。
• set方法不需要返回值类型【用void的】，但是，要考虑形式参数的类型。
• get方法需要返回值类型。但无需考虑传递参数问题。

class Student {
	// 定义姓名属性，并封装
	private String name;
	// 定义年龄属性，并封装
	private int age;

	// 无参构造
	public Student() {
	}

	// 带参构造
	public Student(String name, int age) {
		this.name = name;
		this.age = age;
	}

	// 对外提供set方法，用于设置姓名、年龄
	public void setName(String name) {
		this.name = name;
	}

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

	// 对外提供get方法，用于获取姓名、年龄
	public String getName() {
		return name;
	}

	public int getAge() {
		return age;
	}

	// 定义方法：学习
	public void study() {
		System.out.println("学生在学习");
	}
}

内部类

概述

   将A类定义在B类中，此时，A类就称为内部类（嵌套类、内置类） 

内部类的特点：

   内部类可以直接访问其外部类的成员，包括私有成员

   外部类若要访问内部类的成员，必须创建内部类对象

内部类的分类

   定义在成员位置上的类，叫做成员内部类

   定义在方法中的类，叫做局部内部类

如果想在测试类中，直接使用成员内部类，只需：

   外部类名.内部类名 变量名 = 外部类对象.内部类对象

即：外部类名.内部类名 变量名 = new 外部类名().new 内部类对象()

 

成员内部类的修饰符(private和static)

成员内部类的修饰符

   A： private 修饰是为了考虑安全性

   B： static 修饰是为了方便调用

   如果成员内部类用 static 修饰那么调用的方式是

   外部类名.内部类名 变量名 = new 外部类名.内部类名();

局部内部类的使用

   注意：局部内部类如果访问方法中的局部变量,那么这个变量必须用final修饰

   目的：为了延长它的生命周期

匿名内部类

定义

   没有名字的局部内部类

前提条件

   有个类，或者抽象类，或者接口（一般情况下，是抽象类和接口较为常见）

格式

   new 类名或接口名() {

      重写抽象类或接口中的抽象方法

      也可以自己定义一些特有的功能

   };

解释：通过匿名对象其实就是获取到了一个该接口的子实现类对象。

以后遇到匿名内部类的形式是,一个方法的形参位置要求传递一个接口类型的对象.

   有一个接口叫 Inter

   public void show(Inter i) {

}

什么时候使用匿名内部类

   所有父类出现的地方完全可以使用子类去替代。

class Outer {
	// 成员变量
	private int num = 10;

	// 成员内部类
	class Inner {
		public void show() {
			System.out.println(num);
		}
	}

	// 成员方法
	public void method() {
		// 创建成员内部类对象
		Inner i = new Inner();
		i.show();
	}
}

class InnerTest {
	public static void main(String[] args) {
		// 创建Outer对象，通过Outer对象调用method方法，进行实例化Inter
		Outer o = new Outer();
		o.method();

		// 直接创建Inner对象。
		Outer.Inner oi = new Outer().new Inner();
		oi.show();

		// 创建匿名对象
		new Outer().new Inner().show();
	}
}