Java面向对象编程

初识面向对象

  • 面向过程思想

    • 步骤清晰简单，第一步做什么，第二步做什么。
    • 面向过程适合处理一些较为简单的问题。

  • 面向对象思想

    • 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
    • 面向对象适合处理复杂的问题，适合处理需要多人协作的问题。
  • 面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。
  • 三大特性：封装，继承，多态。

类与对象的关系：

  • 类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。
  • 对象是抽象概念的具体实例。

创建与初始化对象

  • 使用new关键字创建对象。

  • 使用new关键字创建对象的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。

  • 类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：

    • 必须和类的名字相同。
    • 必须没有返回类型，也不能写void。
  1. package oop.demo02;
  2. public class Person {
  4.     String name;
  6.     //一个类即使什么都不写，它也会存在一个方法
  7.     //显示的定义构造器
  9.     public Person(){
  11.         this.name="松哥";
  12.     }
  14.     //只要有一个构造函数，默认构造函数就不会生效了
  15. }
  1. package oop.demo02;
  3. public class Student {
  4.     //属性：字段
  5.     String name;
  6.     int age;
  8.     //方法
  9.     public void study(){
  10.         System.out.println(this.name+"在学习。");
  11.     }
  12. }
  1. package oop.demo02;
  3. //一个项目应该只存在一个main方法
  4. public class Application {
  5.     public static void main(String[] args) {
  8.         //类是抽象的，需要实例化。
  9.         Student xiaoming = new Student();
  10.         Student xiaohuang = new Student();
  12.         xiaoming.name="小明";
  13.         xiaohuang.name="小黄";
  15.         xiaoming.study();
  16.         xiaohuang.study();
  17.     }
  18. }

封装（数据的隐藏）

  • 通常，因禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

代码练习：

  1. package oop.demo03;
  3. //类 private:私有
  4. public class Student {
  6.     //属性私有
  7.     private String name;    //名字
  8.     private  int id;    //学号
  9.     private char sex;   //性别
  11.     //提供一些可以操作这个属性的方法
  12.     //提供一些public的get、set方法
  14.     //get 获得这个数据
  15.     public String getName(){
  16.         return this.name;
  17.     }
  18.     //set 给这个数据设置值
  19.     public void setName(String name){
  20.         this.name=name;
  21.     }
  23.     public int getId() {
  24.         return id;
  25.     }
  27.     //alt+insert 快捷生产get、set方法
  28.     public void setId(int id) {
  29.         this.id = id;
  30.     }
  32.     public char getSex() {
  33.         return sex;
  34.     }
  36.     public void setSex(char sex) {
  37.         this.sex = sex;
  38.     }
  39. }
  1. package oop.demo03;
  3. public class Application {
  4.     public static void main(String[] args) {
  5.         Student student = new Student();
  7.         student.setName("树梢的阳光");
  8.         System.out.println(student.getName());
  9.     }
  10. }

继承

  • 继承的本质是对某以批类的抽象。
  • extands的意思是”扩展“。子类是父类的扩展。
  • java中类只有单继承，没有多继承。
  • 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
  • 子类和父类之间，从意义上讲应该具有”is a“的关系。

代码练习：

  1. package oop.demo04;
  3. //在Java中，所有的类都默认直接或间接继承Object类。
  4. //父类
  5. public class Person {
  6.     public int money=10_0000_0000;
  7.     public int age;
  8.     public char sex;
  9.     protected String name="树梢的阳光";
  11.     public void say(){
  12.         System.out.println("说了一句话。");
  13.     }
  14. }
  1. package oop.demo04;
  3. //Person的子类
  4. //子类继承了父类，就会拥有父类的全部属性和方法，私有的东西  不能继承。
  5. public class Student extends Person{
  7.     private String name="树梢的阳光的儿子";
  9.     public void test(String name){
  10.         System.out.println(name);
  11.         System.out.println(this.name);
  12.         System.out.println(super.name);
  13.     }
  15. }
  1. package oop.demo04;
  3. public class Application {
  4.     public static void main(String[] args) {
  5.         Student student = new Student();
  6. //        student.age=18;
  7. //        student.sxe='男';
  8. //        System.out.println(student.name+"\t"+student.sxe+"\t"+student.age);
  9.         student.test("树梢的阳光正版");
  10.     }
  11. }

super注意点：

  • super调用父类的构造方法，必须在构造方法的第一个。
  • super只能出现在子类的方法或者构造方法中。
  • super和this不能同时调用构造方法。

super vs this：

  • 代表的对象不同

    • this：本身调用者这个对象，调用自己类中的对象。
    • super：代表父类对象的应用，调用的是父类中的对象。

  • 前提

    • this：没有继承也可以调用。
    • super：只有继承了才能使用。

  • 构造方法：

    • this：本类的构造。
    • super：父类的构造。

方法重写

  • 前提：需要有继承关系，子类重写父类的方法。
  • 方法名必须相同。
  • 修饰符：范围可以扩大但不能缩小：public>protected>default>private
  • 抛出的异常：范围可以被缩小不能被扩大。

代码练习：

  1. package oop.demo05;
  3. //重写都是方法的重写，和属性无关
  4. public class B {
  6.     public static void test(){
  7.         System.out.println("B");
  8.     }
  9. }
  1. package oop.demo05;
  3. public class A extends B{
  5.     public static void test(){
  6.         System.out.println("A");
  7.     }
  8. }
  1. package oop.demo05;
  3. public class Application {
  4.     public static void main(String[] args) {
  5.         A a = new A();
  6.         a.test();
  8.         //父类的引用指向了子类
  9.         B b = new A();
  10.         b.test();
  11.     }
  12. }

重写：

  1. package oop.demo05;
  3. public class A extends B{
  5.     @Override
  6.     public void test() {
  7.         System.out.println("A");
  8.     }
  9. }

当改变子类中的输出值时，父类中的输出值也会改变。

重写跟静态方法无关。

多态

  • 即同一方法可以根据发送对象的不同而采用多种不同的行为方式。

  • 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多。

  • 多态存在的条件

    • 有继承关系。
    • 子类重写父类方法。
    • 父类引用指向子类对象。
  • 注意：多态是方法的多态，属性没有多态性。

抽象类

接口

作用：

  • 约束
  • 定义一些方法，让不同的人实现
  • 方法的修饰符是：public abstract
  • 变量的修饰符是：public static final
  • 接口不能被实例化，接口中没有构造方法
  • implements可以实现多个接口
  • 必须重写接口中的方法

内部类

  • 在一个类的内部再定义一个类

  • 成员内部类

    • ```java package oop.demo09;

public class Outer { private int id; public void out(){ System.out.println(“这是外部类的方法”); }

  1. public class Inner{
  3.     public void in() {
  4.         System.out.println("这是内部类的方法");
  5.     }
  7.     //获得外部类的私有属性
  8.     public void getID(){
  9.         System.out.println(id);
  10.     }
  11. }

}

  3.    - 
  4. ```java
  5. package oop.demo09;
  7. public class Application {
  8.     public static void main(String[] args) {
  10.         //通过外部类来实例化内部类
  11.         Outer outer = new Outer();
  12.         Outer.Inner inner = outer.new Inner();
  13.         inner.getID();
  14.     }
  15. }

  • 静态内部类

    • ```java package oop.demo09;

public class Outer { private static int id; public void out(){ System.out.println(“这是外部类的方法”); }

  1. public static class Inner{
  3.     public void in() {
  4.         System.out.println("这是内部类的方法");
  5.     }
  7.     //获得外部类的私有属性
  8.     public void getID(){
  9.         System.out.println(id);
  10.     }
  11. }

}

  3. - 
  4. 局部内部类
  6.    - 
  7. ```java
  8. package oop.demo09;
  10. public class Outer {
  12.     public void method(){
  14.         class Inner{
  15.             public void in(){
  17.             }
  18.         }
  19.     }
  20. }
  • 匿名内部类

构造器

构造器是一种特殊的方法，用来构造并初始化对象。

构造器的名字应该与类名相同。例如：Date类的构造器名为Date。要想构造一个Date对象，需要再构造器前面加上new操作符，例如：

  1. new Date()