面向对象总结一

第一部分

***主要知识点

l 面向对象的理解

l 类与对象

l private关键字

l 封装

l this关键字

l 继承&方法重写

l 构造方法

 

1.面向对象

  1.1面向对象的概述

    面向对象是Java的基本特征。深刻地理解面向对象是设计良好Java软件项目的基础。

面向对象(Object Oriented,OO)是软件开发过程中使用的一种思维方式 。将功能封装进对象，强调具备了功能的对象，不关注过程。

面向对象是依赖于面向过程。

 

 例如：我们要吃饭时，自己做饭是面向过程的思维过程。

 我们要吃饭时，思考的是去调用饭店提供饭的功能，无需再详细地去解决问题是面向对象的思维过程。

 

     例如：我想买一个电脑，但是我不知道买什么样的好，不懂配置，所以我就找了一个懂电脑配置的人来帮我去买，这样我就从一个执行者变成了一个指挥者，指挥这个人来帮我买电脑，而我找的这个人就是我创建的对象

  1.2面向对象的特点

l 是一种更符合人们思考习惯的思想

l 可以将复杂的事情简单化

l 将程序由执行者转换成为指挥者

  1.3面向对象的特性

l 封装、继承、多态

  

2.类与对象

  2.1类的基本概念

l 具有相同特征（属性）和行为(功能)的一类事物的抽象。

l 类在Java中代码的体现形式：

l  使用class(类)来抽象一个现实生活中的事物

l  定义成员变量对应事物的属性，用private修饰，提供get/set方法

l  定义成员方法对应事物的功能

l 定义格式：

public class 类名{

// 成员变量----- 属性

private 数据类型 变量名1;

private 数据类型 变量名2;

…其他成员变量

 

//成员方法----- 行为

public 返回值类型 方法名(参数类型 参数名，参数类型 参数名2…) {

方法体;

}

每个属性对应的get/set方法

}

示例1：定义一个人类，在人类中有两个成员变量，和吃饭的功能。并给每个属性提供相应的get/set方法        代码：  //人类 public class Person { String name; int age;   public String getName() { return name; }   public void setName(String name) { this.name = name; }   public int getAge() { return age; }   public void setAge(int age) { this.age = age; }   public void eat() { System.out.println("人要吃饭"); }   }

 

  2.2类的使用格式

类的使用非常简单，一般分为两个动作：创建对象与调用方法。

类的定义是现实事物的抽象，真正使用的是类创建的对象。通常使用对象来调用方法。

 

l 对象创建格式:

数据类型  对象名= new 数据类型();

 

l 对象方法的调用：

无返回值：

对象名.方法名(参数);

有返回值：

返回值类型  变量名 = 对象名.方法名(参数);

示例2：       定义一个人类，在人类中有两个成员变量，和吃饭的功能。并给每个属性提供相应的get/set方法，在测试类中给属性赋值，调用eat方法，并将属性打印在控制台上       代码：            //人类 public class Person { String name; int age;   public String getName() { return name; }   public void setName(String name) { this.name = name; }   public int getAge() { return age; }   public void setAge(int age) { this.age = age; }   public void eat() { System.out.println("人要吃饭"); }   }     public class Test { public static void main(String[] args) { Person p = new Person(); p.setName("柳岩"); p.setAge(30); System.out.println(p.getName()+"---"+p.getAge()); p.eat(); } }

 

 

  2.3成员变量

直接定义在类中的变量称为成员变量，在面向对象思想设计上，是类的组成部分。

成员变量通常使用private修饰，阻止本类以外的其他类访问。

成员变量不能重名，局部变量不能重名，成员与局部变量可以重名，但是需要使用this区分。

使用this访问的为成员变量，直接访问的为局部。在方法内访问变量，如果没有该名称的局部变量会自动查找是否有该名称的成员变量。

  2.4成员方法

    正常定义成员方法时，一般是不需要添加static修饰符的。static修饰符会在后边详细简介。

成员方法一般可分为两类

l 没有业务的属性get/set方法，与属性对应

l 有业务的普通方法，属于类的功能

示例1：以上案例中Person类中的name和age就是定义在类中方法外，属于成员变量                   get/set方法和我们自己定义的eat方法都是成员方法

 

  2.5类与对象的关系

类是抽象概念，对象是类的具体实例。我们通常真正使用的是某个类的实例对象，进而调用该对象的方法。

一个类可以有多个对象，一个对象只属于一个类(在讲完多态后会有不同的理解)。

可以说创建对象并调用方法是类最主要的使用方式。

 

   

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

3.封装

  3.1封装的概念

l 隐藏实现细节，提供公共访问方式，就叫封装

l 体现：类、private修饰的成员变量、成员方法以及公共的get/set方法均为封装的一部分。

l setXxx()--->用做给我们的属性赋值

l getXxx()--->用做取值

  3.2 private关键字

l private关键字是私有化修饰符，访问权限修饰符的一种，只有在本类中才能访问的成员，是封装类中成员变量最常用的修饰符。

l 用于修饰成员，包括成员变量与成员方法。

  3.3 this关键字

l this代表当前对象的引用。我们通常 来新用其将本对象中的成员与其他作用域成员区分开来。

l this.属性名   ------  指的是成员变量，用来区分成员变量和局部变量

 

   3.3.1封装案例1     

题干	编写代码，实现以下功能：  定义一个门类Door  门类有2个属性，宽度 width 和 高度 height。要求属性私有，提供set  get方法  门类有 开门openDoor 和关门closeDoor  的方法  开门方法：在控制台输出“门已经打开，请进！”  关门方法：在控制台输出“门已经关闭，禁止进入！  定义一个测试类，测试类中定义一个main方法  在main方法中创建一个门对象，使用创建出的门对象 调用门的开门和关门方法。用set方法为属性赋值 宽为1.5   高为 2 。然后获取属性值
所属知识点	封装
题目类型	代码题
答案	public class Demo01_fengZhuang { public static void main(String[] args) { //创建一个Door对象 Door door = new Door(); //对属性赋值 door.setWidth(1.5); door.setHight(2); //获取属性值 System.out.println("门的宽度为：" + door.getWidth() + ",门的高度为：" + door.getHight()); //调用开门方法 door.openDoor(); //调用关门方法 door.closeDoor(); } }   class Door { //定义属性 private double width; private double hight;   // set  get  方法 public double getWidth() { return width; } public void setWidth(double width) { this.width = width; } public double getHight() { return hight; } public void setHight(double hight) { this.hight = hight; } //开门方法 public void openDoor(){ System.out.println("门已经打开，请进！"); } //关门方法 public void closeDoor(){ System.out.println("门已经关闭，禁止进入！"); } }

   3.3.2封装案例2

    

题干	编写代码，实现以下功能：  分析：      手机的属性：        品牌，颜色      手机的功能：        打电话   用到的知识：运用private来修饰，来提供访问权限        测试类:        创建手机类对象;调用set方法为手机的属性赋值,打印出赋值后的属性;调用功能方法
所属知识点	封装
题目类型	代码题
答案	public class Test { public static void main(String[] args) { //创建手机类的对象   Phone p = new Phone();    //调用set方法，为手机类赋值   p.setName("诺基亚");   p.setColor("屎黄");   //调用get方法获取我们赋值的内容   System.out.println(p.getName()+"-----"+p.getColor());    //对象调用手机类的方法    p.call(); } } class Phone { //品牌  颜色，用private来修饰-->这两个属性成为成员变量-->定义在类中，方法外 private String name; private String color; //提供get/set方法 public String getName() { return name; } //set方法中的参数成为局部变量-->定义在方法内 public void setName(String n) { this.name = n; }     public String getColor() { return color; }     public void setColor(String c) { this.color = c; } //手机的功能 public void call(){ System.out.println("打电话"); } }

 

4.继承

  4.1继承的概念

当一个类的属性与行为或者换成相反的角度来看，如果多个类具有相同的属性和行为，我们可以抽取出共性的内容定义父类，这时再创建相似的类时只要继承父类即可。

均与现有类相似，属于现有类的一种时，这一个类可以定义为现有类的子类。

子类拥有父类的所有属性与方法，无需重新定义。并且可以直接使用非私有的父类成员。

从类与类之间的设计关系来看,子类必须属于父类的一种时，才会继承。

我们在完成一个庞大项目体系的时候，都是将共性的内容抽取出，后续构建过程是从各种父类“向外”扩散的。

 

l 比如：猫，狗都属于动物类，而动物都会吃饭，我们就可以抽取出共性的内容，将我们的动物定义成父类，而猫和狗都属于动物类的子类，那么当我们定义猫和狗类的时候就可以继承动物类的吃饭的功能

l 

l 但是，子类继承父类是继承子类们共有的，但是我们的子类中还可以定义自己特有的。比如：猫和狗继承动物类吃饭的功能后，猫类中还可以有抓老鼠的功能；狗类中还可以定义看门的功能

l   4.2继承的定义格继承的定义格式：

   class 子类 extends 父类{

//父类的非私有方法与属性均继承过来

}

式以及使用格式

 

如：

父类的定义：

class Person{

private String name;

public void eat(){

System.out.println(“吃饭”);

}

get/set方法

}

子类继承父类的定义：

class Chinese extends Person{}

 

l 继承的使用格式：

    继承关系的产生通常是为了定义出功能更为具体、更为强大的子类。所以，定义子类后，一般创建子类对象使用。子类可以直接使用父类非私有的成员变量与成员方法

(注：如果成员变量没有使用private修饰，则子类也可直接访问。)

 

子类的使用：

class Test{

public static void main(String[] args) {

Chinese  c = new Chinese();

c.setName(“张大力”);

String name = c.getName();

System.out.println(name);//打印结果为张大力

c.eat();  //打印结果吃饭

}

5.方法重写

  5.1方法重写概念

l   当子类继承父类后，拥有了父类的成员并可以直接调用父类非私有方法。如果子类认为父类提供的方法不够强大，子类可以按照子类自身的逻辑重新定义继承过来的父类方法，这个重新定义一个方法的过程叫做方法重写。

     (注：在学习完多态和抽象类后我们会对方法重写有更深的理解)

l   比如：定义一个人类，在人类中有一个吃饭的功能，子类继承人类后，也有了吃饭的功能，但是怎么吃呢？我们就可以重写人类中吃的方法，方法体中写具体怎么吃。

  5.2方法重写的格式

    子类中定义与父类一样的方法便将父类的方法重写了。此时，当创建子类对象，调用方法时，会调用子类重写后的方法。如：

 

类的定义：

class Person{

public void eat(){

System.out.println(“吃饭”);

}

}

class Chinese extends Person{

public void eat() {

System.out.println(“按照中国的习惯，使用筷子吃”);

}

}

子类的使用：

class Test{

public static void main(String[] args) {

Chinese  c = new Chinese();

c.setName(“张大力”); //父类继承方法直接调用

String name = c.getName(); //父类继承方法直接调用

System.out.println(name); //打印结果为张大力

c.eat();  //方法重写后调用的为重写后的方法

//打印结果：按照中国的习惯，使用筷子吃

}

}

  5.3Java中方法重写规则

l  子类重写方法时，在声明前加@Override可检测该方法是否为重写的方法

l 访问权限相同或子类方法访问权限更大(访问权限顺序public>默认)

l 方法名称必须相同

l 参数列表必须相同

l 返回值为基本类型时必须相同

l 返回值为引用类型时相同或子类小(了解)

  5.4继承注意事项

l Java只支持单继承，不支持多继承。

l 父类可以继承他的父类。

l 所有类均有父类，只有Object类没有父类。

l 在所有使用父类类型的地方均可以传入其子类对象。

 

   5.4.1继承案例1：

     

编写代码，实现以下功能：  需求：定义一个父类，在父类中输出一句话，            定义一个子类，继承父类，并重写父类中的方法,并输出一句话            在测试类中将子类的那句话打印在控制台上

继承，重写

代码题

class Fu { void show() { System.out.println("Fu show"); } } class Zi extends Fu { //子类复写了父类的show方法 void show() { System.out.println("Zi show"); } }   public  class Test{ public static void main(String[] args) { Zi z = new Zi(); z.show(); //如果子类中没有show方法，但是可以找到父类方法去执行;如果子   类中有show方法,那么就按照就近原则执行. } }

 

 

   5.4.1继承案例2：

题干	编写代码，实现如下功能：  * （1）定义一个门类，  *  包含3个属性：宽度width 和 高度height ，颜色color 包含2个方法：开门和关门 开门方法：输出“门已经打开，请进！” 关门方法：输出“门已经关闭，禁止进入！”       （2）定义一个木头门WOOD，继承Door 重写父类开门方法：输出门的高度  宽度  颜色  +“门已经打开，请进！” 重写父类关门方法：输出门的高度  宽度  颜色  +“门已经关闭，禁止进入！”       （3）定义一个测试类，测试类定义一个main方法 分别创建 门对象  和 木头门对象， 为创建的木头门对象属性赋值, 调用开门和关门两个方法。
所属知识点	继承，重写
题目类型	代码题
答案	public class Demo03_jiCheng { public static void main(String[] args) { //创建门对象 Door02 door = new Door02(); // 调用方法 door.openDoor(); door.closeDoor(); //创建木头门对象         WoodDoor woodDoor = new WoodDoor(); //调用set方法对属性赋值 woodDoor.setWidth(1.8); woodDoor.setHight(2.5); woodDoor.setColor("红色"); //调用方法 woodDoor.openDoor(); woodDoor.closeDoor(); } }   class Door02 { //定义属性 private double width; private double hight; private String color; public double getWidth() { return width; } public void setWidth(double width) { this.width = width; } public double getHight() { return hight; } public void setHight(double hight) { this.hight = hight; } public String getColor() { return color; } public void setColor(String color) { this.color = color; } //开门方法 public void openDoor(){ System.out.println("门已经打开，请进！"); } //关门方法 public void closeDoor(){ System.out.println("门已经关闭，禁止进入！"); } }   class WoodDoor extends Door02{   //重写开门方法 public void openDoor(){ System.out.println("门的宽度为："+ getWidth() +"，高度为："+getHight()+"，颜色："+getColor()+"，门已经打开，请进！"); } //关门方法 public void closeDoor(){ System.out.println("门的宽度为："+ getWidth() +"，高度为："+getHight()+"，颜色："+getColor()+"，门已经关闭，禁止进入！"); } }

 

 

6.构造方法

  6.1构造方法的概念

l 用来创建实例对象的方法。

l 创建对象时，可以直接为成员变量赋值，无需再在对象产生后再赋值。

l 构造方法是必须存在的，没有手动给出构造方法，Java会自动为我们补齐一个空参的构造方法。这个过程我们是看不到的。

l 具体类与抽象类均有构造方法，接口没有构造方法。

l 作用：一、创建对象；二、在创建对象的同时给属性赋值

  6.2定义格式

l 一般定义在其他方法前，成员变量后。

l 方法定义格式：没有返回值类型定义，方法名与类名相同

public 类名(参数类型 参数1，参数类型 参数2){

//创建对象时要执行的逻辑，经常为为成员变量赋值

}

 

如：

public class Person{

private String name;

private int age;

  //两个构造方法为重载关系

public Person() {} //空参的构造方法

public Person(String name,int age) { //带参的构造方法

this.name = name;

this.age = age;

}

 

}

l 使用格式：

    构造方法的功能就是创建对象，同时可以为属性赋值。这样当对象创建出来后就已经具备了初始值。

 

new 类型(实际参数);  

 

如：

   //调用set方法赋值

Person p = new Person();  //产生了Person的对象

p.setName(“黄晓明”);

p.setAge(24);

System.out.println(p.getName()+”---”+p.getAge());

 

    //利用构造方法为成员变量赋值

Person p2 = new Person(“AngelaBaby”,18); //产生了一个Person对象

System.out.println(p2);  //打印结果为一个对象地址值，如0252b2

System.out.println(p2.getName()+”---”+p2.getAge()); //打印结果为AngelaBaby

 

   6.2.1构造方法案例1：

题干	编写代码，实现以下功能：  定义一个门类door  门类有2个属性，宽度 width 和 高度 height。要求属性私有，提供set  get方法    无参构造， 满参构造  门类有 开门openDoor 和关门closeDoor  的方法  开门方法：在控制台输出“门已经打开，请进！”  关门方法：在控制台输出“门已经关闭，禁止进入！  定义一个测试类，测试类中定义一个main方法  在main方法中创建一个门对象，使用创建出的门对象 调用门的开门和关门方法。用构造方法为属性赋值 宽为1.5   高为 2 。打印出来，然后再用set方法给属性赋值为宽为3，高为4,5；
所属知识点	继承，构造，封装
题目类型	代码题
答案	public class Demo01_fengZhuang { public static void main(String[] args) { //创建一个Door对象 Door door = new Door(1.5,2); //获取属性值 System.out.println("门的宽度为：" + door.getWidth() + ",门的高度为：" + door.getHight()); //调用开门方法 door.openDoor(); //调用关门方法 door.closeDoor(); } }   class Door { //定义属性 private double width; private double hight; //无参构造 public Door() { super(); } //带参构造 public Door(double width, double hight) { super(); this.width = width; this.hight = hight; } // set  get  方法 public double getWidth() { return width; } public void setWidth(double width) { this.width = width; } public double getHight() { return hight; } public void setHight(double hight) { this.hight = hight; } //开门方法 public void openDoor(){ System.out.println("门已经打开，请进！"); } //关门方法 public void closeDoor(){ System.out.println("门已经关闭，禁止进入！"); } }

      6.2.2构造方法案例2：

题干	雇员示例需求： 公司中:     定义员工类，类中有 姓名，工号，薪水，工作内容 程序员有           姓名，工号，薪水，工作内容。 项目经理除了有     姓名，工号，薪水，工作内容， 还有奖金。     实现思路:     1:所有的属性私有化;定义工作内容方法     2:员工类中提供无参和满参构造,并提供get/set方法     3:经理类继承员工类中相同属性,并定义特有属性     4程序员类继承员工类，重写员工类的工作内容方法     5:分别在测试类中给程序员和经理的属性赋值,并分别将程序员和经理的属性,方法打印出来
所属知识点	继承，构造，封装
题目类型	代码题
答案	class Emplyee //员工 { //姓名，工号，工资 private String name; private String id;//工号 private double salary;//工资 //构造方法 public Emplyee(){} public Emplyee(String name, String id, double salary){ this.name = name; this.id = id; this.salary = salary; } //公共方法 public void setName(String name){ this.name = name; } public String getName(){ return name; } public void setId(String id){ this.id = id; } public String getId(){ return id; } public void setSalary(double salary){ this.salary = salary; } public double getSalary(){ return salary; } public void work(){ System.out.println("工作"); } }   class Programer extends Emplyee// 程序员 { //由于我们已经继承了员工类，那么我们就不需要再定义相同的属性了 //构造方法 public Programer(){} public Programer(String name, String id, double salary){ super(name,id,salary); } public void work(){ System.out.println("程序员工作"); } }   class ProjectManager extends Emplyee// 项目经理 { //由于我们已经继承了员工类，那么我们就不需要再定义相同的属性了，只需要定义我特有的属性就可以了 //成员变量 private double bouns; //奖金 //构造方法 public ProjectManager(){} public ProjectManager(String name, String id, double salary, double bouns){ super(name,id,salary); this.bouns = bouns; } //公共访问方法 setXxx,  getXxx() public void setBouns(double bouns){ this.bouns = bouns; } public double getBouns(){ return bouns; } public void work(){ System.out.println("项目经理工作"); } } public class Test { public static void main(String[] args) { Programer p = new Programer(); p.setName("程序员"); p.setId("343242"); p.setSalary(2.5); p.work(); System.out.println(p.getName()+"---"+p.getId()+"---"+p.getSalary()); System.out.println("============================================="); ProjectManager pm = new ProjectManager(); pm.setName("玉皇大帝"); pm.setId("5454"); pm.setSalary(6.3); pm.setBouns(8.6); pm.work(); System.out.println(pm.getName()+"---"+pm.getId()+"---"+pm.getSalary()+"---"+pm.getBouns()); } }