JavaSE学习笔记第四章（面向对象）

1.面向对象和面向过程的设计思路

·面向过程：（POP）关注于具体流程，一步一步实现解决问题

案例1：把大象装进冰箱

3步可以实现：

1.开门（）；

2.装大象（）；

3.关门（）；

·面向对象：（OOP）

1.先设计：对现实中的事物进行分类 创建出类 在类中定义功能（方法） 创建出具体对象，让对象做具体的事

案例1：把大象装进冰箱

冰箱类{

开门（）；

装大象（）；

关门（）；

}

大象类{

}

总结：面向对象无法取代面向过程，他们相辅相成，面向对象关注于从宏观上把握事物之间的关系，在具体到如何实现某个细节时，仍然采用面向过程的思维方式。

2.Java类

1.类的概念：类是对现实事物的抽象（概念） 一类属性（成员变量）和行为（方法）

2.类的结构：

成员变量：事物的属性

//一般不赋值 不需要初始化 （你赋值了对象创建又复制过去就没有意思了 都一样）Java会用默认值初始化（基本数据类型***(记得了懒得说)；引用类型是NULL）

//哪里可以使用成员变量：

构造方法 成员方法 代码块中可以使用成员变量

方法：行为 功能

构造方法：

代码块：

内部类：（后面讲）

3.类的定义：

[访问权限修饰符] [修饰符] class 类名{

//这里的 [ ] 表示可加可不加

}

3.Java对象

1.对象：客观事物 万物皆对象

2.对象内存简图：

 

创建对象： 对象中复制了一份成员变量 人手一份 方法的话是将方法的地址值传给对象

4.变量的分类

成员变量：事物的属性

//一般不赋值 不需要初始化 （你赋值了对象创建又复制过去就没有意思了 都一样）Java会用默认值初始化（基本数据类型***(记得了懒得说)；引用类型是NULL）

//任何数据类型

//哪里可以使用成员变量：

构造方法 成员方法 代码块中可以使用成员变量

局部变量：在方法、构造方法或者语句块中定义

局部变量使用前必须初始化（赋值）

任意数据类型

方法中的参数也是局部变量（只能在该方法中使用）

5.方法的分类

成员方法：成员方法是定义在类中。

语法格式：

修饰符 返回值类型 方法名 ( 参数列表) {

方法体语句；

[return 返回值]

}

构造方法:用来初始化对象的方法

6.构造方法

构造方法名与类名相同,且没有返回值,且不需要使用void修饰。

作用是为创建的对象初始化

创建对象的时候至少调用一个构造方法 不显示就系统默认给一个构造方法 若定义了一个构造方法 默认构造方法就失效

每个对象创建都会调用一个构造方法

7.方法重载

方法的重载是指同一个类中具有相同的名字，但参数不同的多个方法。

● 参数不同（可以有三方面的不同）

数量不同

类型不同

顺序不同

调用时，会根据不同的参数表选择对应的方法。

注意：方法重载跟方法的返回值类型没有任何关系

构造方法可以重载 成员方法也可以重载

8.对象与引用

按数据类型分类：

基本数据类型：8个 byte short int long flaot double char boolean

引用数据类型：数组 String 自定义的类

对象内存简图：

 

new Person("张三"，22)// 在堆空间创建并储存的对象

Person zs 在栈空间声明的变量

= 把对象在内存中的地址 赋给 左边的变量 左边的变量只是有对象的地址 存的地方都不一样 （赋引用）

哪一个调用showInfo（）方法 那么name age 就是哪个对象的属性

ls.showInfo();

李四的引用调用showInfo()方法

对象在堆存 引用在栈存

值传递和引用传递

Java中进行方法调用中传递参数时，有两种传递方式：

1. 值传递：(形参数类型是基本数据类型)：方法调用时，实际参数把它的值传递给对应的形式参数，形式参数只是用实际参数的值初始化自己的存储单元内容，是两个不同的存储单元，所以方法执行中形式参数值的改变不影响实际参数的值。

2.引用传递：(形参数类型是引用数据类型参数)：也称为传地址。方法调用时，实际参数是对象，这时实际参数与形式参数指向同一个地址，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，这个结果在方法结束后被保留了下 来，所以方法执行中形式参数的改变将会影响实际参数。基本类型传递的是该数据值本身。引用类型传递的是对对象的引用，而不是对象本身

9.static this final关键字

1.this关键字

this关键字代表当前对象，一般使用在引用成员变量 成员方法

在一个类或方法内部，用this.成员变量名来引用成员变量名，用来区分同名的成员变量和局部变量

A类{

int r;

public A(int r){

this.r=r;//表示这个r是构造方法里的r 不是成员变量里的r 就近原则

}

}

2.static关键字

static被称为静态，可以用来修饰类的属性,方法,代码块,内部类

·随类加载而加载

·优先于对象存在

·修饰的成员被所有对象所共享

·修饰的方法可以直接被类调用，不可创建对象//可直接通过类名调用，不需要创建对象

3.final关键字（常量，不可变的）

用于声明方法 属性 类

属性：定义的时候就必须赋值 而且后期都不能改变

（声明时不赋值，就必须在构造方法中逐一赋值）

方法：子类中不可以重写

类：不能被定义为抽象类或是接口 也不能被继承

常常于static一起使用，原则是保证创建每一个对象的时候，final属性的值都是确定的，防止数据在方法体中被修改

10.代码块

代码块在类中加载，类似没有名字的方法体

分类：

·实例代码块：{ java语句 }//每次创建对象自动调用

·静态代码块：static{ java语句 }//随类加载自动调用，仅执行一次，与是否创建对象无关

11.包

用于区别类名的命名空间

包的作用

1.避免类重名

2.按照不同功能管理类

3.控制访问权限

包的命名规范：（全小写）

第一级：项目类型，com(商业),org（机构）,gov（政府）等

第二级：项目所开发或者运行的公司名称，如：oracle,sun,huawei等

第三级 ：项目的名称，如：bcms,oa,erp,cms等

第四级：项目模块的名称，如bean,action,exception等

导入外部包的类，关键字“import”

12.访问权限修饰符

·public 公共的（类，方法，属性，可以被任意类访问）

·protected 受保护的 （方法，属性）（同类，不同包的子类）

·(default) 默认的（就是不写）（类，方法，属性，只能被同包访问）

·private 私有的 （方法，属性）（只能在本类访问，子类也不可以访问）（但是可以通过set,get方法访问）

 

13.面向对象的特征（继承封装多态）

1.封装（隐藏,私有化）

将一些信息隐藏在类中，不允许外部直接访问，但可以通过该类提供的方法（set/get）来实现对隐藏信息的操作和访问

类{

private String name;

//set()方法

public void setName(String name){

if(条件){

//如厨房重地闲人免进，但你可以点单，有的话就会给你做，没有就不行，你符合条件就可以，不符合不可以

this.name=name;

}

}

//get()方法

public String getName(){

return name;

}

}

2.继承（extends）（java是单继承）

继承是面向对象设计不可缺少的设计思想，是实现代码重用的根基，提高代码可扩展性

继承是从已有的类中派生出来的新类，新类吸收了已有类的行为和属性（除了私有的）还可以扩展自己的新能力

1.继承的形式：

[访问权限修饰符] [修饰符] 子类名 extends 父类名{ }

2.继承的传递性：

C继承B，B继承A 则C有A和B类所以非私有的属性和方法

当一个类没有继承任何一个类时，jvm默认继承Object类（基类）

3.继承中的构造方法：

·子类构造方法会先调用父类构造方法

·使用super关键字调用父类任意一个构造方法,必须写在构造方法的第一行

//·如果子类的构造方法中没有显式地调用基类构造方法，则系统默认调用基类无参数的构造方法

4.super关键字用途

使用super关键字访问父类成员 :

• 用super.成员变量名来引用父类成员变量

• 用super.方法名（参数列表）访问父类的方法。

• 用super.构造方法(参数列表)访问父类构造方法//写在方法第一行

//不是创建父类对象，是将父类的信息加载到子类对象储存

5.方法的重写：

方法名相同，参数列表相同

返回值类型相同

访问权限不能小于父类权限

public>procted>default>private

(构造方法 静态方法不能重写，成员变量不存在重写)

3.多态：同一种事物在不同表现出的不同状态

1.多态存在的三个必要条件:

·要有继承（包括接口的实现）

·要有重写

·父类的应用指向子类对象 //Animal cat=new Cat();

(编译看左边，运行看右边)

2.多态的好处：

提高代码的扩展性

方法参数具有多态性

class Animal{

void eat() {}

}

class Cat extends Animal{

void eat() {}

}

class Dog extends Animal{

void eat(){}

}

//方法的形式参数类型是父类类型，而传递的实际参数可以是任意

子类的对象

method(Animal animal){

animal .eat();

向上转型：Animal animal=new Cat();

向下转型：Animal animal=new Cat();

Cat cat=(Cat)animal;//把上升到动物的又强制转型下降到Cat类型

cat.eat();//子类父类中的方法都可以调用

为了使用子类中独有的方法

}

14.抽象类(abstract)

1.语法：

[访问权限] abstract class A类名{

成员列表

public abstract 方法名（）；//抽象方法

//abstract修饰 只有声明，没有具体实现，需要子类来实现

}

public class B extends A {

具体实现

}

·抽象类不能实例化对象（即抽象类不能创建对象），但成员变量 成员方法 构造方法依然存在

·一个类如果包含抽象方法，就必须定义为抽象类

·子类继承抽象父类的话就必须实现父类中的抽象方法，不然子类也要定义为抽象类

15.接口（interface）

1.接口存在的意义：

Java 中一个类只能有一个父类，接口可以实现多继承的逻辑

从本质上讲：接口是一种特殊的抽象类，有抽象方法（就是功能定义，谁想要这个功能就接这个接口 自己重写）

2.接口的定义：

[访问权限修饰符] interface 接口名

//可以再接 （直接接在后面即可） extends 其他接口1，其他接口2.....

3.接口的使用(类使用implements关键字，放在class后面)

[访问权限修饰符] class 类名 implements 接口名1，接口名2...{ }

4.结合继承：

[访问修饰符] class 子类名 extends 父类名 implements 接口1，接口2...{ }

4.接口的特征:

·接口是隐式抽象，声明时不需要用abstract

·接口中方法可以是抽象的 静态的 默认的

·接口中的属性默认为public static final的

·接口不是被类继承 而是被类实现

·接口不能实例化对象，无构造方法

·与继承关系类似，接口与实现类之间存在多态性

·当一个类实现接口的时候，类要实现接口中所有的抽象方法，否则类必须声明为抽象类