一、Java面对对象的概念：

概念：面向对象程序设计（OOP）是一种程序设计的泛型，同时也是一种程序开发的方法，它将对象作为程序的基本单元，将程序和数据封装其中，以提高软件的重用性、灵活性和扩展性

Java 类及类的成员
属性（成员变量）
行为（行为方法）
构造器

面向对象的三大特征
封装（encapsulation）
继承（inheritance）
多态（Polymorphism）

其他关键字
this
super
final
static

面向对象的思想概述

• 面向对象和面向过程的实例 人把大象装进冰箱

  

面向对象的思想概述

程序员从面向过程的执行者转换成了面向对象的指挥着。
买内向对象分析方法分析问题的思路和步骤 ：
根据问题需要，选择问题所针对的现实世界中的实体。
从实体中寻找解决问题相关的属性和方法，这些属性和功能就形成了概念世界中的类
把抽象的实体用计算机语言进行描述，形成计算机世界中类的定义。即借助某种程序语言，把类构造成计算机能够识别和处理的数据结构。
将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具。

二、类和对象的基本概念

类：抽象名词，代表一个集合,共性的事物

对象：具象的事物，单个个体

• 类和对象的关系
  • 对象：代表一类事物的某一个个体
  • 类：代表的是一大类事物

类中的内容，应该具有两个内容

• 表明事物的特征，是静态属性(变量)
• 表明事物功能或动作，是动态属性也称方法(函数)

 类：类是现实世界在计算机中的反映，它将数据和对这些数据的操作封装在一起（并没有开空间）

类的定义

1.定义一个简单的类

2.类的对象可以直接通过 . 来访问类的公有成员，类的对象指针可以通过->来访问类的公有成员  

类和对象的三种方法

• 实例方法

  • 需要实例化对象才能使用的方法

• 静态方法

  • 不需要实例化，通过类直接访问
  • 不使用类或对象的命名空间，其实就是一个函数

• 类方法

  • 不需要实例化
  • 该方法涉及到操作静态属性(所有对象都拥有的属性)、类方法、静态方法

类的三个访问限定符

1.public：公有的，类的成员可以从类外直接访问

2.private/protected：类的成员不能从类外直接访问

3.类的每个访问限定符可以多次在类中使用，作用域为从该限定符开始到下一个限定符之前/类结束

4.类中如果没有定义限定符，则默认为私有的（private）

三、封装的概念：

封装：是将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。

封装的好处：只能通过规定方法访问数据

 1.隐藏类的实现细节

 2.方便加入控制语句

 3.方便修改实现

经过封装的属性，不能直接访问，要通过公共属性get/set方法访问。

1.1封装属性

 package com. bai . demo;
//定义了一个规范人信息的类
public class Person {
    //名字
      String  name ;
      //年龄
      private int age;
}

此时发现了外部程序不能访问age属性了，提示的错误是“这个属性不可见”那么如果一个属性不能访问就失去了本身意义,我们应该为这个封装的属性在内部提供方法(接口)来访问该属性,这样的方法需要两个:一个是取得该属性( getter方法)，另外一个是为该属性赋值(setter 方法)

1.2提供setter和getter方法访问age属性

 package com.bai . demo;
//定义了一个规范人信息的类
public class Person {
    //名字
      String name;
      //年龄
      private int age;
      public void setAge(int myage) {
        age=myage ;
      }
      public int getAge() {
       return   age;
   }
  }

 

 package com. bai . demo;
public class Hello {

 

 public static void main(String[] args) {
    Person per=new Person( ) ;
      Person per=new Person( ) ;
      per. name="李四";
      per. setAge(-10);
      System. out. println("我的名字是:"+per . name) ;
      System. out . print1n("我的年龄是: "+per. getAge());
  }
}

}

当我们通过方法来访问属性的时候我们可以在方法中做-一些逻辑判断，让数据更完全。比如说我们可以在方法中判断你输入的年龄是否合理。

 1.3 setter 方法中判断年龄

package com. bai . demo;
//定义了一个规范人信息的类
public class Person {
  //名字.
   String   name ;
   //年龄
    private int age;
    public void setAge( int  myage) {
     if(myage<=0||myage>200) {//如果传入 年龄为负数则使用默认值
        age=10;
     }else {
       age=myage;
  }
}
    public int   getAge() {
      return   age ;
  }
}
 

package com. bai . demo ;
public class Hello {
  public static void main(String[] args) {
      Person per=new Person( );
      per. name="李四";
      per.setAge(1000);
      System. out . println("我的名字是: "+per . name);
      System. out. println("我的年龄是: "+per. getAge());
   }
 }

 

在开发中一个类的属性基本都要封装，尤其是简单Java类(JavaBean)需要封装，封装之后要为封装的属性提供setter个getter方法。

总结:

1、封装的好处:

可以让程序内部结构更安全

可以把重复的代码封装，之后再需要的地方进行调用，在一定程度上解决了代码的重复

2、今天学习的是封装的最小概念(属性的封装)

3、封装的属性要提供setter和getter方法

4、setter 和getter方法的书写规则:

●setter 方法: set+首写字母大写的属性名， 没有返回值(void)，有参数。

●getter 方法: get+首写字母大写的属性名，有返回值，没有参数。

四、继承

继承的概念：所谓的继承就是在原有的代码结构上扩充新的功能，继承解决的是代码的重复的现象

继承的目的：父母的被子女继承，表示父母的归属到子女。

继承的语法:

public class子类 extends 父类{}

继承的机制：首先分析多个类的共同特征，把相同的特征和行为抽离出来形成一个基类，可以让这些类继承基类，而不需要在类本身中再定义相同的属性和行为。

注意：

子类出了可以继承父类的操作还可以扩充自己新的操作，而且子类不能继承父类的构造方法

一个父类可以有多个子类，但是一个子类只能有一个父类

例题：

教师和学生都属于人，他们具有共同的属性：姓名、年龄、性别和身份证号，而学生还具有学号和所学专业两个属性，教师还具有教龄和所教专业两个属性。下面编写 Java 程序代码，使教师（Teacher）类和学生（Student）类都继承于人（People）类，具体的实现步骤如下。

1）创建人类 People，并定义 name、age、sex、sn 属性，代码如下：

public class People {
    public String name; // 姓名
    public int age; // 年龄
    public String sex; // 性别
    public String sn; // 身份证号
    public People(String name, int age, String sex, String sn) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.sn = sn;
    }
    public String toString() {
        return "姓名：" + name + "\n年龄：" + age + "\n性别：" + sex + "\n身份证号：" + sn;
    }
}

2）创建 People 类的子类 Student 类，并定义 stuNo 和 department 属性，代码如下：

public class Student extends People {
    private String stuNo; // 学号
    private String department; // 所学专业
    public Student(String name, int age, String sex, String sn, String stuno, String department) {
        super(name, age, sex, sn); // 调用父类中的构造方法
        this.stuNo = stuno;
        this.department = department;
    }
    public String toString() {
        return "姓名：" + name + "\n年龄：" + age + "\n性别：" + sex + "\n身份证号：" + sn + "\n学号：" + stuNo + "\n所学专业：" + department;
    }
}

3）创建 People 类的另一个子类 Teacher，并定义 tYear 和 tDept 属性，代码如下：

public class Teacher extends People {
    private int tYear; // 教龄
    private String tDept; // 所教专业
    public Teacher(String name, int age, String sex, String sn, int tYear, String tDept) {
        super(name, age, sex, sn); // 调用父类中的构造方法
        this.tYear = tYear;
        this.tDept = tDept;
    }
    public String toString() {
        return "姓名：" + name + "\n年龄：" + age + "\n性别:" + sex + "\n身份证号：" + sn + "\n教龄：" + tYear + "\n所教专业：" + tDept;
    }
}

 4）编写测试类 PeopleTest，在该类中创建 People 类的不同对象，分别调用它们的 toString() 方法，输出不同的信息。具体的代码如下：

public class PeopleTest {
    public static void main(String[] args) {
        // 创建Student类对象
        People stuPeople = new Student("王丽丽", 23, "女", "410521198902145589", "00001", "计算机应用与技术");
        System.out.println("----------------学生信息---------------------");
        System.out.println(stuPeople);
        // 创建Teacher类对象
        People teaPeople = new Teacher("张文", 30, "男", "410521198203128847", 5, "计算机应用与技术");
        System.out.println("----------------教师信息----------------------");
        System.out.println(teaPeople);
    }
} 

 运行程序，输出的结果如下：

----------------学生信息---------------------
姓名：王丽丽
年龄：23
性别：女
身份证号：410521198902145589
学号：00001
所学专业：计算机应用与技术
----------------教师信息----------------------
姓名：张文
年龄：30
性别:男
身份证号：410521198203128847
教龄：5
所教专业：计算机应用与技术