Java面向对象

一.类和对象
1.概念
--1.类：一组具有公共特征或者行为的对象的集合，对象的模板。               
--2.对象：对象是类的实例，具体存在的事物。

2.定义
类的定义：
[访问修饰符]  class 类名{
    //成员变量
   
    //成员方法

   //构造方法

}
对象定义：
类名  对象名 =   new   类名()

public class Person{
    String name;
    public void Print(){
        System.out.println("我的名字是:" + name);
    }
}
3.成员
1.成员变量：
对象.成员变量

2.成员方法:
对象.成员方法(参数)

3.构造方法:
类名(参数)
this(参数)【自调用】

4.类的方法
定义：
[访问修饰符]  [其他修饰符]  返回值类型  方法名(参数列表)  throws 异常列表{
     //方法体
     [return 返回值]
}
注意： 方法的单一性原则，即一个方法名只能实现一个功能

 4.1重写（Override）
概况：重写方法的覆盖，即子类覆盖父类的方法。

目的：父类的方法无法满足子类的实际需求

特点：
        1.继承或者接口实现
        2.方法名相同
        3.参数相同
        4.返回值相同
        5.访问修饰符子类不能严于父类

 4.2重载（Overload）
概括：一个类中定义多个参数列表不同的同名的方法

特点：

        1.同一个类中，同一个方法的不同体现形式
        2.方法名相同
        3.参数列表不同(参数个数、参数类型、参数顺序)
        4.与返回值类型和访问修饰符无关

5.构造方法
作用： 堆中创建对象，分配内存空间，并且完成对象的初始化。

注意：
       1.构造方法方法名与类名一致。
       2.构造方法在实例化是调用。
       3.构造方法没有返回值类型，不用void修饰。

6.类的运行原理
加载.class的类文件到内存的方法区。
堆中类的创建对象，并且完成对象的初始化。
将对象的地址赋值给栈中引用。
调用类的方法，则方法压栈  [ 先进后出]
垃圾回收器：类的对象无更多的引用指向，垃圾回收器会回收对象资源，释放内存。
       运行垃圾回收器： System.gc()

         退出程序：System.exit(0);

二.封装
1.概念
将对象的全部属性和方法结合在一起形成一个不可分割的独立单位

2.目的
解决程序的安全性问题

3.实现
将类的属性私有化private
给类的各个字段属性提供getter/setter方法
在getter/setter方法中加入流程控制语句
4.关键字
this
意义:
this当前对象的引用本身

使用:
this.属性
this.方法
this(参数)

注意:
如果this调用本类构造时，一定要写在代码的第一行

static
static:静态的
意义: static修饰的成员属于类的成员。
调用方法:  类名.成员名称

注意:
1.静态方法中不能直接调用本类的实例成员，可以直接掉本类的静态成员。
2.实例方法中可以直接调用本类的实例成员，也可以直接调用本类的静态成员。
3.静态方法中不能使用 this  | super关键字 

三.继承
1.概念
子类继承父类的所有特征或者行为，即父类所拥有的子类也全部拥有。

2.目的
解决程序的复用性问题

3.实现
访问修饰符  class  子类 extends 父类{
     //成员变量

     //成员方法

}

4访问修饰符
                      本类              同包               子类               其他
public              Y                   Y                    Y                 Y       
protected        Y                   Y                    Y                 N
默认                 Y                   Y                    N                 N 
private            Y                   N                   N                  N

5.注意事项
      1. 单继承：一个子类只能有一个父类，一个父类可以有多个子类。
      2.传递性：继承中的特征或属性可以传递给后代，即C继承B，B继承A，那么C也继承了A中的成员。
      3.单向性：即子类可以调用父类成员，但是父类不能调用子类成员。
      4.内存中，子类继承了父类所有成员，private或者默认成员子类也继承了，但是无访问权限。

6.关键字super
四.多态
1.概念
同一个引用类型指向不同的实例，从而执行不同的操作

2.目的
解决程序的拓展性问题

3.实现
方法的覆盖(继承 | 接口)
父类的引用指向子类的对象
   
   编译时多态：
   在编译阶段，方法的引用属于哪个类则调用哪个类的方法。

   运行时多态：
   在运行阶段，父类的引用会堆中实际的对象类型，根据实际属于哪个类，查找该对象实际的方法原型从而实现方法的调用。

4.abstract（抽象）
4.1抽象类
定义时机： 不希望实例化该类，认为实例化该类没有任何意义或价值。
例如：
public  abstract class Person{.....}

注意：
      1.抽象类不一定有抽象方法，抽象类中允许有实例方法。
      2.抽象类不能被实例化，抽象类有构造方法。
      3.拥有抽象方法的类一定是抽象类。
      4.子类继承抽象类，子类必须重写抽象类的方法，否则子类也必须定义为抽象类。

4.2抽象方法
定义时机：  实现方法体，没有意义或价值。

例如：
public abstract void show()

注意事项：
          1.拥有抽象方法的类一定是抽象类。
          2.抽象方法没有方法体。

5.接口
5.1定义与实现
接口概念：
接口是程序必须遵守的约束或者规范。

接口定义：
[访问修饰符] interface 接口名称{
    //成员变量
   //成员方法
}

接口实现：
public class 类 implements 接口列表{
  
}

5.2特点
接口的成员变量必须是 public & static & final 常量
接口的成员方法必须是 public & abstract 或者 public & static 
接口不能被实例化，没有构造方法
接口可以多实现。
一个接口可以继承多个接口