Java学习之面向对象的总结

Java面向对象（oop）

1、类

万物皆对象

类名 对象名 = new 构造函数;

只要new出来的对象就永远不一样

• 类：只要是class关键字修饰的关键字就是一个类
• 成员变量：是定义在类中的变量
• 局部变量：定义在方法中的变量
• 对象：通过类new出来的就是对象

八种基本类型都存在默认值，除了八种基本类型剩选的都null；

因为对象类型默认值为null，null代表是不存在，当null调用任何的属性和方法，都和报空指针异常

隐式处理，默认数组最后一个元素都有逗号

Java.lang.*是Java官方默认引入的

引入约束：只能引入一个唯一的相同类名

import  //引入包

package  //包

import  java.util.Scanner  //导入这个包

java.util.Scanner.Scanner  sc=new Scanner(System.in)  //另一种引入包的方法   如果要使用两个不同包的通一个类  就要用这种方法

类中可以创建方法，但是不能调用方法

普通方法如果没有调用，永远都不会执行

1.1、内部类

1.2、静态内部类

2、修饰符

2.1、权限修饰符

• public:共有的 （谁都可以用我）
• private:私有的（只有我自己能用） 私有的类在目前版本中不需要实现
• protected（继承关系可用）
• friendly：有好的（同包可以使用的类） 当class 没有权限修饰符时， 就是有好的类

2.2、静态修饰符（static）

static（官方建议静态的内容，通过静态的方式访问）

static只能修饰成员变量、方法和内部类

static修饰的方法中的内容都是static（不能显示写出）

2.3.终极修饰符（final）

官方允许定义final修饰的未初始化的成员变量，但是必须要编写对应的构造函数完成初始化。

final 修饰class，代表类不能被继承

final 修饰的属性 不能被修改

final 修饰的方法 不能被重写

final定义的变量可以默认不初始化，但是只能被初始化一次。

3、方法（method）

• 完成的就是类中对应的行为-----逻辑代码
• Java中，辨识一个方法的唯一性，1.方法名 2.形式参数（个数不同，类型不同就是不同方法）
• 变量名与方法的辨识唯一无关
• 方法名相同其他不同叫重载方法（overload）
• 方法与方法之间可以互相调用
• 每一个方法的最后一行都会存在一个return隐式状态
• 静态方法里面不能使用this.属性的情况
• 非静态方法可以调用静态方法，但静态方法不能调用非静态方法。

4、构造器

• 构造器：也称为构造函数或者构造方法
  作用：就是为了初始化整个类，并且生成一个独立对象
• 每一个类中至少都会有一个构造器的存在
• 如果某一个类没有手动写出构造器，那么类中会有一个隐式构造器（默认构造器）
• 结构为： 类名（）{} 并且这个名字和类名一定要大小写匹配
• 如果手动显示的写出任何的构造器，那么默认的构造器就会消失（切记）
• 构造器也可以进行重载
• 构造器没有返回类型，并且也不能写出void修饰

• 重载的方法或者构造函数没有个数要求，理论上可以有无数个。

• 在构造函数的第一行会有一个隐式调用：super(); -------继承

• super(); 对应有另一种手动调用法则 this();

• super(); 调用父类的无参的构造函数

• this(形参);手动调用自身类指定的构造函数

  

5、语句块

语句块可以出现在任意的位置

{} 大部分时候，语句块只是一个障眼法，没有任何的实质意义

static语句块 --> {}语句块 --> 构造器

static语句块（语句块）是在类加载时执行

普通语句块中可以嵌入普通语句块，但是不允许嵌入static语句块

静态语句块块中可以嵌入普通语句块，但是不允许嵌入static语句块

静态语句块不能被嵌套

方法中可以定义类

题目

类，方法

6、继承（extends）

• 继承(子永远比父亲强大)
• 在每一个类中都存在继承，而默认的类中存在一个隐式继承 extends Object
• 在java中最大的父类就是Object
• 继承默认会把所有的public修饰的成员变量和方法继承过来
• 在java中，继承都是单一关系，但是可以存在多层关系
• 在java中，每一个子类，只会有一个直接父类，但是会有多个间接父类
• java中的多层继承，没有层级约束
• 每一个类要找到Object这个父类才是最终继承节点

**Field 属性 **

method 方法

class 类

constructor 构造器

7、方法重写（override）

• 重写：如果子类重写了父类的方法，那么当创建子类对象，并且调用次方法名时，默认执行的是子类的方法

• 在继承中，调用一个方法时，首先检查子类是否存在此方法，如果存在，则直接调用，如果不存在，则寻找父类是否存在此方法

• 实际开发中，重写的方法必须加入@Override标识

• 成员变量在继承中没有重写 属性的隐藏

7.1重写和重载的区别（笔试题）

重写（override）

1. 方法名相同
2. 形参相同
3. 返回类型也要相同
4. 权限修饰符 子类的权限修饰符和父类一致，或者比父类更开放(public>protected>friendly>private)
5. 在继承中，父子类才会发生重写
6. 不能重写static或者final定义的父类方法，但是子类可以使用final，static不能使用
7. 子类重写的异常不能抛出比父类更多的异常

重载（overload）

1. 方法名相同
2. 形参不同
3. 重载和方法的返回类型无关
4. 重载是发生在同一个类的规则（继承中没有重载的概念）
5. 重载与修饰符无关

在使用System.out.print()输出一个对象时，会存在一个隐式调用toString()；

8、多态与抽象

对象的不同形态

多态的前提是继承关系

多态的分类：

• 静态多态：使用重载方法
• 动态多态：

  • 向上转型 一个子对象可以被当作一个父类类型。

  • 

  • 继承世界中，越大的父类，容量越大（类似于八种基本类型的大小范围）

  • 在多态中属性的调用，接收类型是什么类型，那么调用的就是此类中的属性

  • 在多态中方法的调用，首先检查是哪一个对象的构造方法生成，对应调用此对象的最近的方法

  • 多态找方法：首先查找左边接收类型中是否存在此方法名，如果不存在，则查找父类中是否存在此方法，如果都不存在则报错

  • 当查询到此方法存在时，从构造函数类型中开始检查方法是否被重写，如果重写，则执行最后一此重写的内容

  • 多态找属性：首先查找左边接收类型中是否存在此属性，如果不存在，这找多态的强转：

9.1、接口的特点

成员变量：public final static int a=int a(默认隐式修饰符)

• 定义的成员变量都是静态常量 接口中的默认隐式修饰符是public static final 并且不可改
• 老版本的jdk中，接口中定义的方法只能是抽象方法，而新版本的jdk1.8开始可以定义实例化方法
• 接口没有构造函数，接口无法直接创建对象（对象创建必须调用构造函数），只能间接创建对象
• 最基本的间接式创建对象：Day011_01 e = new Day011_ 01() {};
• new Day011_01() {}：这种写法的语法名叫做匿名内部类

public interfae a{
    void check();
    default void check(int a){}  //1.8之上可以使用此方法的实现方法
    //default关键字只能是interface中定义实体方法
}

• 类只能单一继承，接口可以多重继承
• 类继承的永远是类，接口继承的永远是接口
  • 接口没有任何方法去继承类

9.2、接口的实现(implements)

类支持实现多重接口

10、抽象（abstract）

• 抽象类中有构造函数-----只要是class类，就就一定有构造函数
• 只要是抽象类，就不能直接调用构造函数创建对象
• 抽象类中定义的抽象方法，没有隐式
• 必须要实现抽象类中的所有方法，才可以创建此类的对象
• A a =new A(){};创建对象
• 抽象类中可以没有抽象方法
• 只要有抽象方法就一定是抽象类
• 在java中，继承和实现是两套基准
• 类与类，接口与接口都是继承关系
• 但是类于接口通过实现关联
• 如果一个类没有实现完接口所有抽象方法，那么此类一定是抽象类
• 如果一个类不是抽象类，那么此类一定实现了接口的所有的抽象方法
• 只能类去实现接口，不能接口实现类
• 抽象类不能使用final、static、private修饰

11、异常（Exception）

异常处理的每个程序员都必须要面对的情况

捕获异常

• 捕获异常（拦截异常、抓取异常）：异常的抓取，永远遵守各司其职，如何抓捕的异常没有匹配，那么抓捕会失败
• 如果异常没有被捕获，那么整个程序都不会执行了
• 如果try包含异常代码，出现异常后代码接着走，服务器继续执行
• 如果try上面的代码出现异常，那么会直接跳到catch里面
• 继承关系 ： 越大的父类管控能力越强
• catch可以使用多个
• 多catch行为必须是从小到大（继承关系）捕获
• try/catch不能分离，分开就是语法错误
• 如果try/catch后有finally，return 就跳finally
• try、catch只能放在方法中，不能放在类中

//try尝试   catch抓取
/*try{
    
}catch(疑似的异常 变量名){
    
}*/

try{
    Integer.parseInt("a");
}catch(NumberFormatException e){
    e.printStackTrace();  //类似于System.out.print();
    System.out.println("对不起，请输入纯数字");   //UE  用户体验度（好看。好用）
}finally{
    //如果一个try catch中存在finally，那么不够是否出现异常，都必须执行finally的代码
}

• throws Exception 抛出异常
• 类名上不允许throws 异常
• throws 并不检查每一个Exception的范围和大小
• 谁用方法，谁就应该捕获异常
• throws 是在方法头上扔出一个或者多好异常
• throw 是在方法语句中扔出一个异常对象
• throw扔出的异常和检查的代码可能一点关系都没有 歧义
• throw不能随意扔出检查性异常
• 子类在重新父类方法时，可以清除throws所以的异常
• 重新的异常范围只能小于或等于父类的异常范围

希望可以和大家互相学习，谢谢大家！！！