一、面向对象
1.1、理解什么是面向过程、面向对象
面向过程与面向对象都是我们编程中,编写程序的一种思维方式。
面向过程的程序设计方式,是遇到一件事时,思考“我该怎么做”,然后一步步实现的过程。
例如:公司打扫卫生(擦玻璃、扫地、拖地、倒垃圾等),按照面向过程的程序设计方式会思考“打扫卫生我该怎么做,然后一件件的完成”,最后把公司卫生打扫干净了。
面向对象的程序设计方式,是遇到一件事时,思考“我该让谁来做”,然后那个“谁”就是对象,他要怎么做这件事是他自己的事,反正最后一群对象合力能把事就好就行了。
例如,公司打扫卫生(擦玻璃、扫地、拖地、倒垃圾等),按照面向对象的程序设计方式会思考“我该让谁来做,如小明擦玻璃、让小丽扫地、让小郭拖地、让小强倒垃圾等” 这里的“小明、小丽、小郭、小强”就是对象,他们要打扫卫生,怎么打扫是他们自己的事,反正最后一群对象合力把公司卫生打扫干净了。
1.2、面向对象举例
实例:
买电脑(组装机)
先使用面向过程说明买电脑这件事:假如我们需要买组装电脑,这时首先会在网上查询具体每一个硬件的参数和报价。然后会去电脑城进行多家询价,接着询价结束后回家根据具体的结果分析出自己比较满意的哪家报价,接着会到这家店里进行组装,组装时还需要进行现场监督,组装完成安装相应的系统,然后电脑抱回家。
分析上述整个过程大体分一下几步:上网查询参数和报价、电脑城询价、现场安装和监督、抱电脑回家。在整个过程中我们参与了每一个细节,并且会感觉相当累。
使用面向对象说明买电脑这件事:假如我们需要买组装机,这时应该找一个懂电脑硬件的人,让他帮我们查看参数和报价,并进行询价和杀价,以及现场组装监督。而我们自己并不需要亲历亲为具体怎么做,只要告诉这个人我们想要的具体需求即可。
分析上述整个过程,发现瞬间变的十分轻松,只要找到懂电脑硬件的这个人,我们的问题都可以解决。并且在这个过程中我们不用那么辛苦。
1.3、面向对象思维方式的好处
通过生活中的真实场景使用面向对象分析完之后,我们开始分析面向过程和面向对象的差异做出总结:
1)面向对象思维方式是一种更符合人们思考习惯的思想
2)面向过程思维方式中更多的体现的是执行者(自己做事情),面向对象中更多的体现是指挥者(指挥对象做事情)。
3)面向对象思维方式将复杂的问题简单化。
二、类与对象
2.1、对象在需求中的使用
对面向对象有了了解之后,我们来说说在具体问题中如何使用面向对象去分析问题,和如何使用面向对象。
我们把大象装冰箱为例进行分析。在针对具体的需求,可以使用名词提炼的办法进行分析,寻找具体的对象。
需求:把大象装进冰箱里
对象:大象、冰箱
分三步:
1)打开冰箱门
2)把大象装进去
3)关上冰箱门
分析发现,打开、装、关闭都是冰箱的功能,即冰箱对象具备以下功能:
冰箱打开
冰箱存储
冰箱关闭
用伪代码描述,上述需求中有两个具体的事物: 大象 和 冰箱
描述大象:
class 大象{
}
描述冰箱:
class 冰箱{
void 打开(){}
void 存储(大象){}
void 关闭(){}
}
当把具体的事物描述清楚之后,需要使用这些具体的事物,Java使用具体的事物,需要通过new 关键字来创建这个事物的具体实例。
1)使用对象
冰箱 BX=冰箱();
2)调用冰箱功能
对象.功能();
BX.打开();
BX.存储(new 大象());
BX.关闭();
总结:
1)先按照名词提炼问题领域中的对象
2)对对象进行描述,其实就是在明确对象中应该具备的属性和功能
3)通过new的方式就可以创建该事物的具体对象
4)通过该对象调用它以后的功能。
2.2、对象在代码中的体现
在分析现实生活中的事物时发现,这些事物都有其具体的特点和功能,这些特点和功能就组成了这个特殊的事物。
描述小汽车。
分析:
事物的特点(属性):颜色
轮胎个数。
事物的(功能):运行。
发现:事物其实就是由特点(属性)和行为(功能)组成的。
可以简单理解:属性就是数值,其实就是变量;行为就是功能,就是方法。
小汽车{
颜色;
轮胎个数;
运行(){ }
通过计算机语言Java来描述这个事物。
1、定义类的格式
public class类名{
/ /可编写0至n个属性
数据类型变量名1;
数据类型变量名2;
/ /可编写0至n个方法
修饰符返回值类型方法名(参数){
执行语句
汽车类
public class Car {
String color;
int number;
void run(){
System.out.print1n(color+":"+ number);
}
}
通过代码的描述,知道类的真正意义就是在描述事物。属性和功能统称为事物中的成员。事物的成员分为两种:成员属性和成员功能。
成员属性在代码中的体现就是成员变量成员功能在代码中的体现就是成员方法
把写好的代码测试一下。需要一个可以独立运行类。
1)创建对象的格式:
类名 对象名=new类名();
2)测试类
public class CarDemo {
public static void main(String [] args) {
// 测试:car类中的run方法。
//1 创建car的对象。给对象起个名字
Car c=new Car(); // c是类类型的变量。c指向了一个具体的car类型的对象。
//2 通过已有的对象调用该对象的功能。格式:对象.对象成员,
// 3 可以该对象的属性赋值。
c.color="red";
c.number=4;
c.run();
}
}
2.3、对象的内存图解
经过上面对小汽车的描述,和Java代码测试,我们虽然可以将生活中的事物使用Java代码描述出来,但是这些代码在内存中是如何执行的,接下来我们需要研究下对象在内存的图解。
接下来就是分析对象在内存中的分配情况。这里需要画图一步一步演示,严格按照画图流程讲解内存对象创建过程。
2.4、类和对象的区别
面向对象的编程思想力图在程序中对事物的描述与该事物在现实中的形态保持一致。为了做到这一点,面向对象的思想中提出两个概念,即类和对象。其中,类是对某一类事物的抽象描述,而对象用于表示现实中该类事物的个体。接下来通过一个图例来抽象描述类与对象的关系,如下图所示:
在上图中,可以将玩具模型看作是一个类,将一个个玩具看作对象,从玩具模型和玩具之间的关系便可以看出类与对象之间的关系。类用于描述多个对象的共同特征,它是对象的模板。对象用于描述现实中的个体,它是类的实例。从上图中可以明显看出对象是根据类创建的,并且一个类可以对应多个对象,接下来分别讲解什么是类和对象。
经过前面几个知识点的学习,基本上掌握了类是用于描述事物的,类中可以定义事物的属性和行为。而对象是通过描述的这个类,使用new关键字创建出来,通过对象就可以调用该对象具体的属性和功能了。
2.5、局部变量和成员变量的区别
理解清楚了类和对象之后,结合前5天的学习知识,发现在描述类的属性和前面学习定义变量差别不大,唯一区别就是位置发生了改变,那么类中定义的变量,和在方法定义的变量有啥差别呢?回忆以前学习时变量的定义方式,和位置,以及现在定义类中属性的特点。总结下面几点异同
1)区别一:定义的位置不同
定义在类中方法外的变量是成员变量
定义在方法中或者{}语句里面的变量是局部变量
2)区别二:在内存中的位置不同
成员变量存储在对内存的对象中局部变量存储在栈内存的方法中
3)区别三:声明周期不同
成员变量随着对象的出现而出现在堆中,随着对象的消失而从堆中消失局部变量随着方法的运行而出现在栈中,随着方法的弹栈而消失
4)区别四:初始化不同
成员变量因为在堆内存中,所有默认的初始化值
局部变量没有默认的初始化值,必须手动的给其赋值才可以使用。
2.6、基本类型和引用类型作为方法参数传递
引用类型数据和基本类型数据作为参数传递有没有差别呢?我们用如下代码进行说明,并配合图解让大家更加清晰
基本类型作为参数传递时,其实就是将基本类型变量x空间中的值复制了一份传递给调用的方法show(),当在show()方法中x接受到了复制的值,再在show()方法中对x变量进行操作,这时只会影响到show中的x.当show方法执行完成,弹栈后,程序又回到main方法执行,main方法中的x值还是原来的值。
当引用变量作为参数传递时,这时其实是将引用变量空间中的内存地址(引用)复制了一份传递给了show方法的d引用变量。这时会有两个引用同时指向堆中的同一个对象。当执行show方法中的 d.x=6时,会根据d所持有的引用找到堆中的对象,并将其x属性的值改为6.show方法弹栈。
由于是两个引用指向同一个对象,不管是哪一个引用改变了引用的所指向的对象的中的值,其他引用再次使用都是改变后的值。
三、封装
3.1、封装概述
在面向对象程式设计方法中,封装(英语:Encapsulation)是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。
封装可以被认为是一个保护屏障,防止该类的代码和数据被外部类定义的代码随机访问。
要访问该类的代码和数据,必须通过严格的接口控制。
封装最主要的功能在于我们能修改自己的实现代码,而不用修改那些调用我们代码的程序片段。
适当的封装可以让程式码更容易理解与维护,也加强了程式码的安全性。
封装的优点:
1. 良好的封装能够减少耦合。
2. 类内部的结构可以自由修改。
3. 可以对成员变量进行更精确的控制。
4. 隐藏信息,实现细节。
3.2、实现Java封装的步骤
1. 修改属性的可见性来限制对属性的访问(一般限制为private)
例如:
public class Person {
private String name;
private int age;
}
这段代码中,将 name 和 age 属性设置为私有的,只能本类才能访问,其他类都访问不了,如此就对信息进行了隐藏。
2. 对每个值属性提供对外的公共方法访问,也就是创建一对赋取值方法,用于对私有属性的访问
例如:
public class Person{
private String name;
private int age;
public int getAge(){
return age;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public void setName(String name){
this.name = name;
}
}
采用 this 关键字是为了解决实例变量(private String name)和局部变量(setName(String name)中的name变量)之间发生的同名的冲突。
3.3、实例
/* 文件名: EncapTest.java */
public class EncapTest{
private String name;
private String idNum;
private int age;
public int getAge(){
return age;
}
public String getName(){
return name;
}
public String getIdNum(){
return idNum;
}
public void setAge( int newAge){
age = newAge;
}
public void setName(String newName){
name = newName;
}
public void setIdNum( String newId){
idNum = newId;
}
}
以上实例中public方法是外部类访问该类成员变量的入口。
通常情况下,这些方法被称为getter和setter方法。
因此,任何要访问类中私有成员变量的类都要通过这些getter和setter方法。
通过如下的例子说明EncapTest类的变量怎样被访问:
/* F文件名 : RunEncap.java */
public class RunEncap{
public static void main(String args[]){
EncapTest encap = new EncapTest();
encap.setName("James");
encap.setAge(20);
encap.setIdNum("12343ms");
System.out.print("Name : " + encap.getName()+
" Age : "+ encap.getAge());
}
}
以上实例运行结果如下:
Name : James Age : 20
四、继承
4.1继承的概念
继承是java面向对象编程技术的一块基石,因为它允许创建分等级层次的类。在现实生活中,继承一般指的是子女继承父辈的财产。在程序中,继承描述的是事物之间的所属关系,通过继承可以使多种事物之间形成一种关系体系。
继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为。
例如:
兔子和羊属于食草动物类,狮子和豹属于食肉动物类。
食草动物和食肉动物又是属于动物类。
所以继承需要符合的关系是:is-a,父类更通用,子类更具体。
虽然食草动物和食肉动物都是属于动物,但是两者的属性和行为上有差别,所以子类会具有父类的一般特性也会具有自身的特性。
4.2 继承的格式和使用
在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的,一般形式如下:
class 父类 {
}
class 子类 extends 父类 {
}
接下来我们通过实例来说明这个需求。
开发动物类,其中动物分别为企鹅以及老鼠,要求如下:
企鹅:属性(姓名,id),方法(吃,睡,自我介绍)
老鼠:属性(姓名,id),方法(吃,睡,自我介绍)
企鹅类:
public class Penguin {
private String name;
private int id;
public Penguin(String myName, int myid) {
name = myName;
id = myid;
}
public void eat(){
System.out.println(name+"正在吃");
}
public void sleep(){
System.out.println(name+"正在睡");
}
public void introduction() {
System.out.println("大家好!我是" + id + "号" + name + ".");
}
}
老鼠类:
public class Mouse {
private String name;
private int id;
public Mouse(String myName, int myid) {
name = myName;
id = myid;
}
public void eat(){
System.out.println(name+"正在吃");
}
public void sleep(){
System.out.println(name+"正在睡");
}
public void introduction() {
System.out.println("大家好!我是" + id + "号" + name + ".");
}
}
从这两段代码可以看出来,代码存在重复了,导致后果就是代码量大且臃肿,而且维护性不高(维护性主要是后期需要修改的时候,就需要修改很多的代码,容易出错),所以要从根本上解决这两段代码的问题,就需要继承,将两段代码中相同的部分提取出来组成 一个父类:
公共的父类:
public class Animal {
private String name;
private int id;
public Animal(String myName, int myid) {
name = myName;
id = myid;
}
public void eat(){
System.out.println(name+"正在吃");
}
public void sleep(){
System.out.println(name+"正在睡");
}
public void introduction() {
System.out.println("大家好!我是" + id + "号" + name + ".");
}
}
这个Animal类就可以作为一个父类,然后企鹅类和老鼠类继承这个类之后,就具有父类当中的属性和方法,子类就不会存在重复的代码,维护性也提高,代码也更加简洁,提高代码的复用性(复用性主要是可以多次使用,不用再多次写同样的代码) 继承之后的代码:
企鹅类:
public class Penguin extends Animal {
public Penguin(String myName, int myid) {
super(myName, myid);
}
}
老鼠类:
public class Mouse extends Animal {
public Mouse(String myName, int myid) {
super(myName, myid);
}
}
4.3 继承的特性
1)子类拥有父类非private的属性,方法。
2)子类可以拥有自己的属性和方法,即子类可以对父类进行扩展。
3)子类可以用自己的方式实现父类的方法。
4)Java的继承是单继承,但是可以多重继承,单继承就是一个子类只能继承一个父类,多重继承就是,例如A类继承B类,B类继承C类,所以按照关系就是C类是B类的父类,B类是A类的父类,这是java继承区别于C++继承的一个特性。
5)提高了类之间的耦合性(继承的缺点,耦合度高就会造成代码之间的联系)。
4.4 继承的关键字
继承可以使用 extends 和 implements 这两个关键字来实现继承,而且所有的类都是继承于 java.lang.Object,当一个类没有继承的两个关键字,则默认继承object(这个类在 java.lang 包中,所以不需要 import)祖先类。
1、extends关键字
在 Java 中,类的继承是单一继承,也就是说,一个子类只能拥有一个父类,所以 extends 只能继承一个类。
public class Animal {
private String name;
private int id;
public Animal(String myName, String myid) {
//初始化属性值
}
public void eat() { //吃东西方法的具体实现 }
public void sleep() { //睡觉方法的具体实现 }
}
public class Penguin extends Animal{
}
2.super与this关键字
super关键字:我们可以通过super关键字来实现对父类成员的访问,用来引用当前对象的父类。
this关键字:指向自己的引用。
实例:
class Animal {
void eat() {
System.out.println("animal : eat");
}
}
class Dog extends Animal {
void eat() {
System.out.println("dog : eat");
}
void eatTest() {
this.eat(); // this 调用自己的方法
super.eat(); // super 调用父类方法
}
}
public class Test {
public static void main(String[] args) {
Animal a = new Animal();
a.eat();
Dog d = new Dog();
d.eatTest();
}
}
以上实例运行结果如下:
animal : eat
dog : eat
animal : eat
3.final关键字
final 关键字声明类可以把类定义为不能继承的,即最终类;或者用于修饰方法,该方法不能被子类重写:
声明类:final class 类名 {//类体}
声明方法:修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}
注:实例变量也可以被定义为 final,被定义为 final 的变量不能被修改。被声明为 final 类的方法自动地声明为 final,但是实例变量并不是 final
4.5 构造器
子类不能继承父类的构造器(构造方法或者构造函数),但是父类的构造器带有参数的,则必须在子类的构造器中显式地通过super关键字调用父类的构造器并配以适当的参数列表。
如果父类有无参构造器,则在子类的构造器中用super调用父类构造器不是必须的,如果没有使用super关键字,系统会自动调用父类的无参构造器。
实例:
class SuperClass {
private int n;
SuperClass(){
System.out.println("SuperClass()");
}
SuperClass(int n) {
System.out.println("SuperClass(int n)");
this.n = n;
}
}
class SubClass extends SuperClass{
private int n;
SubClass(){
super(300);
System.out.println("SubClass");
}
public SubClass(int n){
System.out.println("SubClass(int n):"+n);
this.n = n;
}
}
public class TestSuperSub{
public static void main (String args[]){
SubClass sc = new SubClass();
SubClass sc2 = new SubClass(200);
}
}
以上实例运行结果如下:
SuperClass(int n)
SubClass
SuperClass()
SubClass(int n):200