零基础学习java（五）

面向对象的理解：

java作为纯面向对象的语言，比C语言即简洁又简单，那么面向对象的思想有什么好处呢？

1：面向度想想思想：

面向对象是一种更符合我们思考习惯的思想，他是基于相对于面向过程的一种编程思想。
能把复杂的事情简单化，让我们从执行着变成了指挥者。这里面就要说到类与对象的关系

(1)类：现实世界的事物：属性：事物的特征。行为：事物的功能
(2)java中最基本的单位是类。所以，我们要把事物转换为对应的类。
(3)如何转换呢：类-事物。成员变量-属性。成员方法-行为。
成员变量：属性，字段。成员方法：函数，方法。
(4)类与对象的概念
类：是一组相关的属性和行为的抽象的集合体。（学生）
对象：是该类事物的具体存在的个体。               （小明）

2：类与对象的使用：面向对象：如何让我们的代码更符合面向对象思想
A:有哪些类 。B:类有哪些功能。C:类与类的关系。

3：成员变量和局部变量的区别
(1)在类中的位置不同：成员变量：类中方法外。局部变量：方法中或者方法声明上。
(2)在内存中的位置不同：成员变量：堆中。局部变量：栈中。
(3)生命周期不同：成员变量：随着对象的存在而存在，随着对象的消失而消失。
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失。
(4)初始化值不同；成员变量：有默认初始化值。局部变量：没有默认初始化值。

4:变量什么时候该定义成员变量
(1)如果变量和类之间存在这描述性的关系，就该定义为成员变量。
(2)注： 变量的定义范围越小越好。  
(3)引用类型作为参数和返回值的问题：
A:如果一个方法的形式参数是一个类名，那么，这里肯定需要的是该类的对象。
B:如果一个方法的返回值是一个类名，那么，这里返回的肯定是该类的对象。
5:匿名对象
(1)就是没有名字的对象。
(2)应用场景：
A:调用方法。但是仅仅只调用一次的时候使用。B:作为实际参数传递。Demo d = new Demo();
d.printStudent(new Student());
6:封装
(1)隐藏实现细节，提供公共的访问方式。
(2)体现有哪些呢? A:类。 B:方法体。 C:private修饰成员变量
(3)private关键字：是私有的意思。可以修饰类中的成员变量和成员方法。
注：被它修饰的成员只能在本类中被访问。
(4)标准代码：

class Student {private String name;private int age;public void setName(String n) {name = ni;}public String getName() {return name;}public void setAge(int a) {age = a;}public int getAge() {return age;}}

7:构造方法
(1)创建对象，并对对象的内容进行初始化。
(2)特点：A:方法名和类名相同。B:没有返回值类型。C:没有返回值。
(3)注： A:如果我们没给构造方法，系统给出一个默认构造。无参构造。
         B:如果我们给出了构造方法，系统将不再提供构造方法。
这个时候，要么我们不使用无参构造方法。要么，自己定义一个，然后使用。推荐：自己给出无参构造方法。
(4)给成员变量赋值的方式：A:无参+setXxx()。B:带参。
(5)获取值：getXxx()
(6)标准代码：

class Student {private String name;private int age;public Student() {}public Student(String n,int a) {name = n;age = g;}public void setName(String n) {name = ni;}public String getName() {return name;}public void setAge(int a) {age = a;}public int getAge() {return age;}}

8：this关键字
(1)代表当前类的一个对象。谁调用代表谁。
(2)应用场景：A:使用本类的成员变量。this.变量名;
B:使用本类其他构造方法。this(...)。C:使用本类的其他成员方法。this.方法名();
9：static关键字
(1)是静态的意思，可以修饰类中成员变量和成员方法。
(2)静态的特点：A:随着类的加载而加载。B:优先于对象存在。C:被所有对象共享的数据。
这个也被我们作为为什么要使用静态的一个判断条件。举例：饮水机和水杯。
D:让我们的调用多了一种方式：a:非静态的数据，必须创建对象访问。
b:静态的数据，可以通过对象访问，也可以通过类名访问。
(3)静态的访问问题：
A:非静态方法：非静态成员变量、静态成员变量、非静态成员方法、静态成员方法。
B:静态方法：静态成员变量、静态成员方法
总之：静态只能访问静态。
称呼： 静态的成员被成为类成员。跟类相关。非静态的成员被称为实例成员。跟对象相关。
(4)main方法的解释以及如何接收键盘录入数据：
public:权限最大。static:静态，不用创建对象。void:返回没有意义。main:大家都是这样做的。
String[] args:接收键盘录入数据。

10：final
(1)是一个关键字，表示的是最终的意思。
(2)它可以修饰类，修饰成员变量，修饰成员方法。
(3)特点：它修饰的类不能被继承。它修饰的变量是常量。它修饰的成员方法不能被重写。
方法的形式参数：基本类型：基本类型的值不能发生改变。
引用类型：引用类型的地址值不能发生改变，但是内容可以发生改变。
11：代码块
(1)用{}括起来的代码。
(2)分类：A:局部代码块。方法内。作用：限定变量的生命周期，提高效率。
B:构造代码块。类中，方法外。作用：把所有构造方法中相同的代码定义到一处。
C:静态代码块。类中，方法外，加static。作用：在整个系统运行过程中只执行一次的内容。
(3)面试题：
构造方法，构造代码块，静态代码块的执行流程
静态代码块 -- 构造代码块 -- 构造方法。    特点：静态代码块只执行一次。构造代码块每次调用构造方法都执行。
一个类的实例化过程

Person p = new Person();
1:把Person.class加载到内存。   2:在栈内存为p变量开辟空间。  3:在堆内存为Person对象开辟空间。
4:对成员变量进行默认初始化。  5:对成员变量进行显示初始化。
6:如果有构造代码块，通过构造代码块对成员变量进行初始化。  7:通过构造方法对成员变量进行初始化。
8:对象初始化完毕，把堆内存的地址给p变量。

12：继承
(1)把多个类中相同的内容提取出来，定义到一个类中。 然后让这多个类和这个类产生一个关系，这多个类就具备该类的数据了，这种关系叫：继承。
(2)表现形式：class SonClass extends FuClass {}。SonClass: 子类,派生类。FuClass: 父类，基类，超类
(3)继承的好处：A:提高了代码的复用性。B:让类与类之间产生了一个关系，是多态的前提。
(4)Java中继承的特点：A:Java中类只支持单继承。B:Java中类可以多层(重)继承。
(5)继承间的成员关系：A:成员变量，在子类方法中使用变量：局部范围，成员范围，父类成员范围。
B:构造方法：a:子类构造方法中默认去访问父类的无参构造方法。原因：因为子类要使用父类的数据，父类的数据必须先初始化。
b:假如父类没有构造方法，要么，使用super(...)调用带参要么，使用this(...)访问本类其他构造，本类至少有一个构造方法访问了父类构造方法。
C:成员方法，通过子类对象使用成员方法：子类、父类。
D:方法重写：(1)子类中出现了和父类中方法声明一模一样的方法。复写，覆盖。
(2)注：A:子类方法的权限不能低于父类方法的权限。 B:父类私有的不能被重写。    C:静态只能重写静态。

13：多态
(1)同一个对象在不同时刻表现出现的多种状态。举例：水(水蒸气,冰,水)
理解：  编译时期状态和运行时期状态不一致的现象。
(2)多态的前提：A:要有继承或者实现关系。B:有方法重写。因为一般都是抽象类或者接口的多态。
C:要有父类/父接口的引用指向子类对象。
(3)多态访问的成员特点：Fu f = new Zi();
A:成员变量：编译看左边，运行看左边。
B:成员方法：编译看左边，运行看右边。
C:静态方法：编译看左边，运行看左边。
(4)多态的好处和弊端：
A:好处：提高了程序的可维护性和可扩展性。维护性：继承保证。扩展性：多态保证
B:弊端：父类/父接口不能访问子类特有功能。
(5)多态中的类型转换：A:向上转型：Fu f = new Zi();B:向下转型：Zi z = (Zi)f;
(6)多态的体现形式：   A:具体类多态
class Fu {}
class Zi extends Fu {}
Fu f = new Zi();
B:抽象类多态
abstract class Fu {}
class Zi extends Fu {}
Fu f =  new Zi();
C:接口多态
interface Inter {}//接口的实现类命名：接口名+Im
class Im implements Inter{}
Inter i = new Im();
14：抽象类
(1)把多个类中相同的方法声明给抽取出来。定义到一个类中。
  一个方法如果只有方法声明，没有方法体，那么该方法必须定义为抽象方法。
  而一个类中如果有抽象方法，那么，该类必须定义为抽象类。
(2)抽象类的特点：
A:抽象方法和抽象类都必须用abstract表示。
B:一个类继承抽象类的时候；要么本身是一个抽象类。要么实现抽象类中的所有抽象方法。
C:抽象类不能实例化。可以按照多态的使用方式使用。
D:成员特点：a:成员变量：可以是变量，也可以是常量。
b:构造方法：有。c:成员方法：可以是抽象，也可以非抽象。
(3)抽象类的好处：
A:抽象类中的非抽象方法提高了代码的复用性。 B:抽象类中的抽象方法强制要求子类必须重写某些方法。
(4)抽象类中的几个小问题：
A:抽象类不能实例化，构造方法有什么用呢，用于子类访问父类数据的初始化。
B:如果一个类中没有抽象方法，而类却被定义为了抽象类为什么，不让创建对象。
C:abstract不能和哪些关键字共存：private: 冲突。final: 冲突。static: 无意义
15：接口
(1)如果一个抽象类中的所有成员方法都是抽象的，java就提高了一种更抽象的表达方式：接口。
(2)接口的特点：A:接口用interface定义。类实现接口用implements关键字。
B:一个类要实现接口：要么本身是抽象类。要么实现接口中的所有抽象方法。
C:接口不能实例化。可以按照多态的使用方式使用。
D:成员特点：a:成员变量：只能是常量。 默认修饰符：public static final。b:成员方法：只能是抽象方法。
 默认修饰符：public abstract
(3)类与接口的关系：A:类与类的关系：继承，单继承。
B:类与接口的关系：实现，单实现，多实现。继承一个类的同时实现多个接口。
C:接口与接口的关系：继承，单继承，多继承。
(4)抽象类和接口的区别:
A:成员区别：抽象类：a:成员变量：可以是变量，也可以是常量。
b:构造方法：有。    c:成员方法：可以是抽象，也可以非抽象。
B：接口：a:成员变量：只能是常量。默认修饰符：public static final。
b:成员方法：只能是抽象方法。 默认修饰符：public abstract。
B:关系区别：a:类与类的关系：继承，单继承。b:类与接口的关系：实现，单实现，多实现。
继承一个类的同时实现多个接口。c:接口与接口的关系：继承，单继承，多继承。
C:设计理念不同
抽象类被继承体现的是：is a的关系。抽象类中定义的是继承体系共性功能。
接口被实现体现的是：like a的关系。接口中定义的是继承体系的扩展功能。
分析：从具体到抽象。实现：从抽象到具体。使用：具体。