java学习笔记面向对象

一、面向对象概述

面向对象就是一种思想，面向对象是相对面向过程而言。两者都为思想。
面向过程：强调的是功能行为，注重的是过程与过程中的行为（功能）
面向对象：将功能封装进对象，强调具备了功能的对象。
面向对象是基于面向过程的，即面向过程是面向对象的基础。
面向过程的代表语言：Basic、C
面向对象发展于面向过程，发现每个功能都所属于一个（有一个所属关系，故将功能封装）
面向对象将问题简单化了，我们也从过去的执行者，变为指挥者。
编程思想：先确定对象，在确定对象应有的功能，先在Java中寻找有没有相关对象，若没有，自己创造方法对象，封装功能。

名词提炼法：确定动作有几个对象。
面向对象有三大特征：封装、继承、多态。
以后的开发，其实就是找对象使用，若没有则创建一个对象。
开发的过程：找对象，建对象，用对象，维护对象。

二、类与对象

类：对现实生活中事物的描述。类主要用于描述。描述的内容是属性和行为（变量和方法）

对象：就是现实生活中，实实在在的实体。

类与对象计算Java语言用来描述事物的方式。

类与对象的关系：类是对象的抽象，对象是类的实体（在堆内存中new）

定义类就是描述事物，就是在定义属性和行为。属性和行为共同成为类中成员（成员变量和成员方法）

凡是用于存储多个数据的，我们都称之为实体，都放在堆内存中。

定义对象：就是通过new操作符在堆内存中产生一个实体。
对象的特点在于封装数据。

凡是用于存储多个数据的，我们都称之为实体，都放在堆内存中。

定义对象：就是通过new操作符在堆内存中产生一个实体。
对象的特点在于封装数据。

凡是用于存储多个数据的，我们都称之为实体，都放在堆内存中。

定义对象：就是通过new操作符在堆内存中产生一个实体。
对象的特点在于封装数据。

例：定义一个汽车类，并定义一个类对象：
class Car // 定义Car类
{ String color = “red”; // 成员变量车颜色，轮胎数
int num = 4;
void run() // 成员方法
{ System.out.println(color+”…”+num); }
}
在主函数中定义对象（main函数中）
Car c = new Car(); // 通过new实例化类
c.color = “blue”; // 修改对象的color属性
Car c1 = c; // 新定义对象c1，赋予c的地址
c1.num = 5; // 定义C1的num值为5
c.run(); // 输出调用成员方法，C，C1指向同一对象

自定义类不需要独立运行，故不需要主函数（但也可以创建main）
成员变量与局部变量作用范围不一样，前者作用于整个类，后者作用于函数中或语句中。成员变量存在堆内存中，局部变量存在栈内存中。
自定义类中有可在本类中实例化对象。

匿名对象调用方法有意义，调用属性无意义。
匿名对象使用方式一：
当对对象的方法只调用一次时，可以用匿名对象来完成，比较简化。若对一个对象进行多次或多个成员变量调用，必须给这个对象起名字。
匿名对象使用方式二：
可以将匿名对象作为实际参数进行传递。
匿名对象是对象的简化形式，定义方式为：new 类名();
情况例：new Car().num = 5; // 使用完便失效，匿名对象调变量无意义。
new Car.run(); // 匿名对象调用方法有意义。
main()
{
Car c = new Car(); // 主函数中，实例一个Car对象名为c
show(c); // 调用方法传参c
c = null; // 调用完成，清空对象c的指向，堆中数据成垃圾。
show(new Car()); // 匿名对象作实际参数相当于 Car c = new Car();
public static void show(Car c) // 定义一个方法，参数为Car类型。
{

c.num=3;

c.color=”black”; // 改变参数对象的成员变量值

c.run(); // 调用参数对象的成员方法
}
}
注：匿名类当实际参数时，方法调用结束，堆中数据即成垃圾。
非匿名对象当实参时，只有main函数结束或人工指定，堆中才有垃圾。

三、封装

封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式，（封装：Encapsulation）
封装的好处：将变化隔离，便于使用，提高重要性，提高安全性。
封装的原则：将不需要对外提供的内容隐藏起来。把属性都隐藏，提供公共方法对其访问。
函数是Java中最小的封装体，类也是封装体，包也是封装。框架

四、修饰符

private：私有修饰符，权限修饰符，用于修饰类中成员（成员变量，成员函数）私有只在本类中有效。
若将变量私有化以后，类以外即便建立了对象也不能直接访问，需要在类中提供对应访问方式。
注：一个成员变量通常对应2个访问方式。1、设置set 2、获取get 。
注：私有仅是封装的一种表现形式，不私有也可以封装。
之所以对外提供访问方式是因为可以控制输入值（访问方式中可以加入逻辑判断等语句，提高代码健壮性。）
注：成员变量在堆内存中有初始值，局部变量在栈内存中无默认值。
eg：class Person // 自定义类
{ private int age; // 定义成员变量
public void setAge(inta) // 定义成员变量访问方法
{
if(a>0&&a<130)
{
age = a; // 判断输入是否非法
speak();
}
elseSystem.out.println(“feifa age”); // 合理输出
}
public int getAge()
{ return age; } // 成员变量访问方法
void speak() // 成员方法
{ System.out.println(“age=”+age); }
}
class PersonDemo
{ public static voidmain(String[] args) // 主函
{ Person p = new Person(); // 实例化类对象
p.setAge(-40); // 设置类成员变量，通过访问方法。
}
}

五、构造函数

构造函数特点：函数名与类名相同，不用定义返回值类型，不可写return语句。
构造函数作用：给对象进行初始化。
注：默认构造函数特点。 2、多个构造函数以重载形式存在。
类对象一建立，就会调用与之对应的构造函数，构造函数的作用是，可用于给对象进行初始化。
当一个类中没有构造函数时，那么系统会默认给该类加入一个空参数的构造函数，当类中自定义了构造函数后，默认的构造函数就没有了。
构造函数和一般函数在写法上有不同。在运行上也有不同。构造函数是在对象已建立就运行，给对象初始化。而一般方法是对象调用才执行，给对象添加对象具备的功能。
一个对象建立，构造函数只运行一次，而一般方法可以被对象调用多次。
什么时候定义构造函数？
当分析事物时，该事物存在具备一些特性或者行为，那么，将这些内容定义在构造函数中。
eg：class Person // 注：此类无参数构造，不允许定义无参对象。
{ private String name;
private int age; // 私有成员变量
Person(String n)
{ name = n;
System.out.println(“ ”); // 构造函数（有一个参数）
}
Person (String name,int a)
{ name = n; age=a;
System.out.println(“ ”);
}
public void cry() // 成员函数
{ System.out.println(“cry”);}
}
class PersonDemo2
{ public static voidmain(String[] args)
Person p1 = newPerson(); // 无参构造不合法
Person p1 = new Person(“Lisi”); // 一个参数实例对象
}
private 是用来修饰成员的，故也可以修饰构造函数，用private修饰的构造是不能生成对象的。
注：若局部变量中有所使用的变量，则系统不会在向外层寻找。此时，若成员变量和局部变量重名引入this关键字。
关键字this，指代本类对象，代表它所在函数，所属对象的引用。简单说，哪个对象在调用this所在的函数，this就代表哪个对象。
this的特点：this指的是调用的对象（指向的同一地址）
this关键字的基本应用
当定义类中函数时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象，但凡本类功能内部，使用到了本类对象，都用this表示。
eg：需求：给Person类定义一个用于比较年龄是否相等的函数
public Boolean compare(Person p)
{ return this.age = p.age; } // this指代调用对象

构造函数相互调用，this（相对应参数）
构造函数相互调用，可以更好的实现封装，只公开一个，其他内部调用。构造相互调用的语句必须放在第一个执行语句处，即第一行。
注：死循环调用构造（2个函数相互不停调用）
eg：class Person
{ private String name;
Person()
{}
Person(String name)
{ this.name = name; }
Person(String name,int age)
{ this(); this(name); this.age=age; } //构造调用构造
}

六、继承

继承（extends）： class 子类 extends 父类（超类、基类）
继承的好处：
1、提高了代码的复用性。
2、让类与类之间产生了关系，有这个关系，才有了多态的特性。
注意：千万不要为了获取其他类的功能，简化代码而继承，必须是类与类之间有所属关系才可以继承，所属关系 is a
Java语言只支持单继承，不支持多继承，因为多继承易带来安全隐患，当多个父类中定义了相同功能，当功能内容不同时，子类对象不确定要运行哪一个（优化了c++）但Java保留了多继承机制，并用另一种形式来完成表示（多实现）Java支持多层继承（c extends b，b
extends a），也就是一个继承体系
如何使用一个继承体系中的功能呢？
想要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中共性功能。通过了解共性功能，就可以知道该体系的基本功能。那么这个体系已经可以基本使用了。
在具体调用时，为什么要创建最子类的对象？
一是因为有可能父类不能创建对象，二是创建子类可以使用更多的功能，包括基本的也包括特有的。
简单一句话：查阅父类功能，创建子类对象使用功能。

继承代码体现（继承2）
注：this 本类引用，super父类引用。
子父类出现后，类成员的特点：
类中成员：1、变量 2、函数 3、构造函数
1、变量：如果子类中出现非私有的同名成员变量时，子类要访问本类中的同名变量用this。访问父类中的同名变量时用super，super和this的使用方式一致。
子父类中的函数
函数的覆盖（重写），当子类出现和父类一模一样的函数时，当子类调用该函数，会运行子类函数的内容，如同父类的函数被覆盖一样，这种情况是函数的另一个特性：重写（覆盖）
说明：当子类继承父类，沿袭了父类的功能，到子类中。但是子类虽具备该功能，但是功能的内容却和父类不一致，这时，没必要定义新功能，儿时使用覆盖的特性，保留父类的功能定义，并重写功能内容。
注：重载只看同名函数的参数列表
重写，自弗雷方法要一模一样（包括返回类型、名称、参数）
eg：class Tel // 父类
{
void show()
{ System.out.println(“number”); }
}
class NewTel extends Tel
{
(public)void show() // 覆盖权限必须大于等于父类
{
super.show(); // 调用原类方法，在原基础上增加
System.out.println(“name”);
System.out.println(“pic”);
}
}

子父类中的构造函数
注：super(); 调用父类构造。 this();调用子类构造
在对子类对象进行初始化时，父类的构造函数也会运行，那是因为子类中的构造函数默认第一行有一条隐式的语句super();而super();会访问父类中空参数的构造函数，而且子类中所有的构造函数默认第一行都是super();（所有重载构造前都有一个super();）
子类创建对象时一定会先访问父类中的构造函数，若没有无参构造在父类中，则要显式指明要访问哪个有参构造，并给出参数。
为什么子类一定要访问父类中的构造函数？
因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的，所以子类在对象初始化时，要先访问一下父类中的构造函数。
如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。
注：super语句一定定义在子类构造函数的第一行。
构造函数只this(); 和super(); 在构造函数中只能出现一个都必须第一行。
结论：子类中所有的构造函数，默认都会访问父类中空参数的构造函数，因为子类每一个构造函数内的第一行都有一句隐式super();当父类中没有空参数的构造时，子类必须手动通过super或者this语句形式来指定要访问的构造函数（父类中的）
当然，子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数，子类中至少会有一个构造函数会访问父类中的构造函数，这就是子类的实例化过程。

七、接口

接口：初期理解，可以认为是一个特殊的抽象类，当抽象类中的方法都是抽象方的，那么该类
可以通过接口的形式来表示。
class用于定义类、interface用于定义接口。
接口定义时，格式特点：
1、接口中常见定义：常量，抽象方法。
2、接口中的成员都有固定修饰符。
常量：public static final 方法：public abstract
注：接口中的成员都是public的。
interface中的所有成员有固定修饰符，用户不写会默认添上。
类与类是继承关系，类与接口是实现关系（implements）
eg：class 类名 implements 接口名 { }
接口是不可以创建对象的，因为有抽象方法，需要被子类实现，子类对接口中的抽象方法全部都覆盖后，子类才可以实例化，否则子类是一个抽象类。
注：interface编译后，也产生.class文件。接口名调用接口中的常量也可以。

接口可以被类多实现，实现多个接口之间用逗号连接。
类可以在继承类的同时，实现接口，先继承在实现可以扩展类的功能。
接口间的关系是继承。
eg：interface A{} interface B extends A{}
接口可以多继承（因为无方法体不冲突）
eg：interface A{} interface B{} interface C extends B,A{}

接口的特点
接口是对外暴露的规则
接口是程序的功能扩展
接口可以用来多实现
类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。
接口与接口之间可以有继承关系。

接口用于功能扩展（基本功能定义在类中，扩展功能定义在接口中）
eg：class abstract sporter // 运动员必备功能定义类中
{ abstract void play(); }
interface Studying // 运动员扩展功能定义接口
{ void study(); }
class wangwu extends sporter implements Studying
{ void play(){} public void study(){} }

八、多态

多态：可以理解为事物存在的多种体现形态。
eg：人：男人、女人 动物：猫、狗 eg：猫 x = new 猫(); —> 动物 x = new 猫();
重载和覆盖是函数的多态。
重点了解对象的多态：多态的体现、前提、好处、应用、弊端。
1、多态的体现（提高程序扩展性及复用性）
父类的引用指向了自己的子类对象，即，父类的引用也可以接收自己的子类对象：
父类 x = new 子类();
2、多态的前提：
必须是类与类之间有关系，要么继承，要么实现。通常还有一个前提，存在覆盖。
3、多态的好处：大大的提高了程序的扩展性。
4、多态的弊端：提高了扩展性，但是只能使用父类的引用访问父类成员。
5、多态的应用： 6、多态使用的注意事项：
例：abstract class Animal // 抽象类Animal
{ abstract void eat(); }
class cat extends Animal // Animal子类 cat
{
public void eat(){ System.out.println(“吃鱼”); }
public voidcatchMouse(){ System.out.println(“抓老鼠”); }
}
class Dog extends Animal // Animal子类 dog
{
public void eat(){ System.out.println(“吃骨头”); }
public void kanJia(){ System.out.println(“看家”); }
}
class DuoTaiDemo
{
public static voidmain(String[] args) // 主函数
{
Cat c = new Cat(); // 待验证
Animal a = new Cat();
function(new Cat());
a.eat();
c.eat();
}
public static voidfunction(Animal a) // 多态使用
{ a.eat(); }
}
多态类型转换
eg：Animal a = new Cat(); // 类型提升，向上转换
当使用子类（Cat）特有方法时，如何操作？
Cat c =(Cat) a; c.catchMouse(); // 强制向下转换。
注：不要出现将父类对象转成子类类型。我们转换的是父类应用指向了自己的子类对象时，该应用可以被提升和强转，多态自始至终都是子类对象在做变化。
eg：Animal a = new Animal(); Cat c = (Cat) a; // 错误
修改上节的function方法：
publicstatic void function(Animal a)
{
a.eat();
if(a instanceof Animal)
{ System.out.println(“haha”); }
else if(a instanceof Cat)
{ Cat c = (Cat) a; c.catchMouse(); }
else if(a instanceof Dog)
{ Dog d = (Dog) a; d.Kanjia(); }
}
主函数中：function(new Dog()); function(new Cat());

多态中（父类指向子类对象）成员函数的特点（非静态成员方法）
在编译时期：参阅引用型变量所属的类中是否有调用的方法，如果有，编译通过。如果没有，编译失败。
在运行时期：参阅对象所属的类中是否有调用的方法。
简单总结：成员函数在多态调用时，编译看左边，运行看右边。
在多态中，成员变量的特点：无论编译和运行，都参考左边（引用型变量所属的类）
在多态中，静态成员函数的特点：无论编译还是运行，都参考左边
（静态无this，super只有类名调用，所以不考虑对象）静态绑定。

九、Object类

Object类是类层次结构的根基，每个类都用Object类作为超类。
Object：是所有对象的直接后者间接父类，传说中的上帝，该类中定义的肯定是所有对象都具备的功能。
equals(objectobj)方法，提示其他某个对象是否与此对象“相等”。（多台表现）
equals方法比较的是地址值，而（==）比的是值。
注：Object类中已经提供了对对象是否相同的比较方法。如果自定义类中也有比较相同的功能，没必要重新定义，只要沿袭父类中的功能，建立自己特有比较内容即可，这就是覆盖。

Object类方法简介：
toString()方法，返回该对象的字符串表示。
hashCode()方法，返回该对象的哈希值（八进制）
getClass()方法，返回此Object类的运行时类。
getMethods()方法，返回一个包含某些Method对象的数组。
getName()方法，以String的形式返回此Class对象所表达的实体。
说明：toString()——getClass.getName()+’@’+Integer.toHexString(hashCode()).