03_面向对象
1 基本概念
1.1对象
对象：一切皆对象。
在JAVA中，客观世界存在的都是对象。
对象的组成：属性（名词，成员变量）；行为（方法）。
1.2类
类：对象的模板。
类即是具有相同属性和行为的一组对象的集合。
扩展：
1） 对象和类的区分：对象是具体存在的，而类是抽象的概念。
2）在JAVA中，先创建类，再通过类来创建对象。
3）在同一个文件中，只能有一个类是public的，即具有main()方法的类是public的。
4）当“+”两边任意一边或两边有字符串时，其作用是连接字符串。
2构造方法（构造器、构造函数）
2.1构造方法的作用
构造方法的作用是用来创建对象。
2.2构造方法是一种特殊的方法
2.3构造方法的特点
（1）与类名相同；
（2）没有返回值类型；
（3）每个类都有一个隐式的构造方法，其没有参数，也没有方法体；
（4）如果手动添加构造方法，隐式构造方法即被覆盖；
（5）构造方法只能和关键字new一起使用；以此来创建对象，不能调用；
（6）初始化成员变量。
示例代码：
import java.lang.*;
public class Test{
public static void mian(String args[]){
Person p1 = new Person();
Person p2 = new Person();
}
}
class Person{
Person(){
}
}
3面向对象思想
1.先找有几个对象；
2.通过对象找出有几个类；
3.找出每个类中有哪些属性和方法；
4.调用方法实现功能。
例题：张三吃了李四一根头发。
解题步骤：
第一步找对象：张三、李四、头发；
第二步找类：人、头发；
第三步找属性和方法：属性（名字、头发）；方法（吃）。
示例代码：
public static void main(String[] args){
Person p1 = new Person();
p1.name = "张三";
Person p2 = new Person();
p2.name = "李四";
p2.h = new Hair();
p1.eat(p2.h);
}
class Person{
String name;
Hair h;
public void eat(Hair hair){}
}
class Hair{
}
4专家模式
专家模式：方法改变谁的状态，方法就属于谁。
状态：属性的值（成员变量的值）。
改变对象的状态其实就是改变成员变量的值。
5引用数据类型
引用数据类型：类、数组等等。
Code segement 代码区（字节码）
Heap segement 堆区（对象、成员变量）
Stack segement 栈区（局部变量）
Static segement 静态区（静态变量和字符常量）
静态区是栈的一个特殊区域，其中的数据不能重复。
堆和栈的区别：堆可以保存大数据量的内容，执行速度慢；而栈保存小数据量的内
容，执行速度快。
基本数据类型和引用数据类型的区别：基本数据类型保存的是真实的值，引用数据
类型中保存的不是对象，而是对象的地址，通过地址，可以找到在堆中的对象，所
以变量不是对象，而是对象的引用。
6 this指针
this 指针：每个对象都有this指针，相当于当前对象的引用。
成员变量和局部变量重名，解决的办法：
使用关键字this
用法：this.name（成员变量）
示例代码：
class Person{
static int age;
Person(int age){
this.gae = age;
}
}
7成员变量初始化
在JAVA中成员变量会默认初始化，默认值为0（整数类型）、false（布尔类型）、空 字符（字符类型）、null（引用类型）。
null 值的含义：代表一个引用类型没有引用指向任何对象。
JAVA有垃圾回收机制，可以自动回收JAVA中无用的内存。
什么是无用内存？
答：当一个对象没有引用指向时，这个对象就是垃圾。
8关键字static
static：静态变量（加在成员变量前）；静态方法（加在类方法前）。
类变量的问题：所有的对象共享其数据，一个对象修改其值，其他对象也相应改变，可以以“类名.变量名”的方式来调用。
类方法：不需要创建对象，直接使用“类名.方法名”来调用。
注意：静态方法中，只能访问静态的变量，非静态方法两种变量都可以访问。
问题：main方法为什么是static（静态的）？
答：main方法是程序的入口，在它执行之前不可能有任何对象被创建，所以JVM需要调用main方法只能是static的。
示例代码：
import java.lang.*;
public class Test{
public static void mian(String args[]){
Person p1 = new Person(19);
Person p2 = new Person(20);
System.ou.println(p1.age);
System.ou.println(p2.age);
}
}
class Person{
String name;
static int age;
Person(int age){
this.gae = age;
}
}
9 package 包
JAVA的包机制：用不同的文件夹来区分不同的类。
JAVA类的全名： 包名+类名
import （导包），作用：省略类的
类名的标准：公司的域名倒过来写（如：com.baidu.国家.……）
10 JAVA中的访问修饰符
private （私有）只能类的内部使用
default （默认）在同一个包下的所有类之间都可以使用
protected（保护）两个类不再同一个包，但有继承关系,就可以调用
public （公共）到处都可以使用
11面向对象的三大基本特征
11.1封装：代码复用；屏蔽细节
11.2继承：代码复用；功能上扩展
在JAVA中使用extends关键字来表示两个类的继承关系，当子类继承了一个父类
（super class超类、基类）的时候，子类自动拥有父类的所有成员。
继承（extends）只能是单继承；
JAVA中使用extends关键字来表示两个类的继承关系，当子类继承了父类
时super class 超类、基类）的时候，子类自动拥有父类所有的成员。
示例代码：
public class Test{
public static void mian(String args[]){
Teacher t = new Teacher();
System.out.println(t.name);
}
}
class Person{
String name;
int age;
}
class Teacher extends Person{
int teacherNo;
}
11.3多态：动态绑定、池绑定（一个方法有多种形态）。
多态即是当程序执行的时候，根据传入的参数决定绑定哪个方法。
条件：
1有继承；
2要有父类的引用指向子类的对象；
3有方法的重写。
示例代码：
public class Test{
public static void main(String args[]){
Person.playWithAnimal(new Dog());
}
}
class Person{
public static void playWithAnimal(Animal a){
a.sleep();
}
}
class Animal{
String name;
int age;
public void sleep(){
System.out.println("Animal is sleeping");
}
}
class Dog extends Animal{
String furColor;
public void sleep(){
System.out.println("Dog is sleeping");
}
}
class Cat extends Animal{
public void sleep(){
System.out.println("Cat is sleeping");
}
}
12方法的重写/覆盖（override）
方法的重写是发生在继承关系中，父类中被重写的方法和子类中重写的方法必须拥
有相同的方法名，相同的返回值类型，相同的参数列表，子类的重写方法不能有比父类重
写方法更严格的访问修饰符。
示例代码：
public class Test{
public static void mian(String args[]){
Animal a = new Animal();
a.sleep();
Dog d = new Dog();
d.sleep();
}
}
class Animal{
public void sleep(){
System.out.println("Animal is sleeping");
}
}
class Dog extends Animal{
public void sleep(){
System.out.println("Dog is sleeping");
}
}
13方法的重载（overload）
发生在同一个类中，重载的方法和被重载的方法必须有相同的方法名，必须拥有不同
的参数列表，返回值类型，可以不同，也可以相同。方法重载根据调用方法的时候传入的
参数决定调用哪个方法。
示例代码：
public class Test{
public static void mian(String args[]){
T t = new T();
t.add(1,2);
t.add(1,2,3);
}
}
class T{
public static int add(int a,int b)
System.out.println(a+b);
}
public static int add(int a,int b,int c)
System.out.println(a+b+c);
}
}
14 super关键字
相当于当前父类的的引用。
每一个子类的对象中都有一个父类的对象，因为子类自动拥有父类的所有对象。
JAVA在构建子类的对象的时候，先构建父类对象，再构建子类对象。
（1）当子类成员变量与父类成员变量重名时，需要访问父类成员变量时，用super关键字调用。
Super.成员变量名
（2）重写过程中，子类重写方法需要调用父类的重写方法的时候
super.方法名()
（3）如果父类中没有无参数的构造方法，是不能成功创建子类对象的。需要在子类的构造方法中手动调用父类的构造方法，且必须在第一行。
解释：
1.必须先创建父类对象，再创建子类对象；
2.JAVA是用构造方法来创建对象的；
3.先调用父类的构造方法，再调用子类的构造方法；
4.JAVA默认调用的是父类中无参数的构造方法；
5.给父类提供了一个有参数的显示构造方法，无参的隐式构造方法就不存在了。
示例代码：
public class Test{
public static void mian(String args[]){
Dog d = new Dog();
}
}
class Animal{
public Animal(int num){
}
}
class Dog extends Animal{
public Dog(){
super(10);
System.out.println("*******");
}
}
15对象转型（casting）
向上转型：父类的引用指向子类的对象（只能用父类的对象）
相下转型：强制类型转换。
16 Object类
Object是所有类的根类；也就是说，Object类中的所有的方法其他的类都拥有。
17 toString和equals方法
toString()会默认调用的情况：
1.System.out.println()（控制台上的显示都是字符串）;
2.出现字符串连接符的时候。
“==”比较的是栈区的内容，比较两个对象时，必须用equals比较堆区里面的对象。
JAVA的类，是开发者创建的，我们创建的时候，与这个类相关的比较大小、相等的
规则也要指定。
示例代码：
public class Test{
public static void mian(String args[]){
Person p1 = new Person("Tom",20)
Person p2 = new Person("Tom",20)
System.out.println(p1.equals(p2));
}
}
class Person{
String name;
int age;
Person(String name,int age){
this.name = name;
this.age = age;
}
public String toString(){
return "name:" + this.name + "age:" + this.age;
}
public boolean equals(Object obj){
Person p = (Person)obj;
if(this.name.equals(p.anme)&&this.age==p.age){
return true;
}else{
return false;
}
}
}
18 hashCode（哈希码）
哈希码查找速度最快。
相等的对象一定具有相等的哈希码（重写过equals方法后，一定要重写hashCode方
法）。
注意：具有相等哈希码的两个对象不一定相等。
19 final关键字
加在成员变量前，表示这个是常量（常量名称的每个字母都要大写）。
加在类（方法）前，表示这个类（方法），不能被继承（重写）。
示例代码：
public class Test{
public static void mian(String args[]){
Animal a = new Animal();
a.a();
}
}
class Animal{
public final void a(){
}
}
20 abstract关键字
加在类上，表示这个类是抽象类，不能实例化（instance），即表示不能创建对象。
如果一个类，就是用来被继承的，如：多态，父类引用指向子类的对象，父类不需要
实例化，这时可以指定这个类是抽象的。
加在方法上，表示这个方法是抽象方法（没有方法体），即表示这个方法是用来被重写
的。
注意：有抽象方法的一定是抽象类；而抽象类中可以有非抽象的方法。
示例代码：
public class Test{
public static void mian(String args[]){
Animal a = new Animal();
a.a();
}
}
abstract class Animal{
public abstract void a(){
}
}
21接口（interface）
接口是一种特殊的抽象类。
因为其只能拥有抽象方法和常量。
接口称之为类实现了接口，方法也称之为实现（implements）
接口之间叫继承，接口之间是可以多继承的。
接口可以有多个，父类只能有一个，类与接口之间
示例代码：
public class Test{
public static void mian(String args[]){
System.out.println(Car.num);
Car.run();
Car.stop();
Car.a();
Car.b();
}
}
interface Car extends A,B{
int num = 10;
public void run;//可以省略abstract关键字
public void stop;
}
interface A{
public void a();
}
interface B{
public void b();
}
class BMW implements Car,A{
public void run(){
System.out.println("BWM is running");
}
public void stop(){
System.out.println("BWM is stop");
}
public void a(){
System.out.println("a");
}
public void b(){
System.out.println("b");
}
}
浙公网安备 33010602011771号