javaSE-(面向对象)，javase-面向对象

面向对象概述

面向对象思想

面向过程思想与面向对象思想:

• 面向过程: 面向过程，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。
• 面向对象: 面向对象思想就是不断的创建对象，使用对象，指挥对象做事情。

特点：

• 面向过程: 强调的是过程，所有事情都需要自己完成
• 面向对象:
• 是一种更符合我们思想习惯的思想(懒人思想，我把事情自己不做，交给别人去做)
• 可以将复杂的事情简单化（对使用者来说简单了，对象里面还是很复杂的）
• 将我们从执行者变成了指挥者角色发生了转换

类与对象及其使用

成员变量:

• 就是事物的属性,处于类中，方法外。

成员方法:

• 就是事物的行为,不能用static修饰。

类和对象的概念

• 类: 一组相关属性和行为的集合。
• 对象: 该类事物的具体体现。

对象的内存图: 

方法公用内存图:

两个引用指向同一个对象内存图:

成员变量和局部变量的区别:

• A:在类中的位置不同:
• 成员变量：类中，方法外
• 局部变量：方法中或者方法声明上(形式参数)
• B:在内存中的位置不同:
• 成员变量：堆内存
• 局部变量：栈内存
• C:生命周期不同:
• 成员变量：随着对象的创建而存在，随着对象的消失而消失。
• 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失。
• D:初始化值的问题:
• 成员变量：有默认值。
• 局部变量：没有默认值。必须先定义，赋值，最后使用.

面向对象三大特性：封装-继承-多态

面向对象特性之封装

封装与私有关键字

private关键字：

• a:是一个权限修饰符。
• b:可以修饰成员(成员变量和成员方法)
• c:被private修饰的成员只在本类中才能访问
• 针对private修饰的成员变量，我们会相应的提供getXxx()和setXxx()用于获取和设置成员变量的值,方法用public修饰

封装的概述和好处:

• A:封装概述：
• 是面向对象三大特征之一
• 是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。就像刚才说的年龄。
• B:封装原则：
• 将不需要对外提供的内容都隐藏起来。
• 把属性隐藏，提供公共方法对其访问。
• 成员变量private，提供对应的getXxx()/setXxx()方法
• C:好处：
• 通过方法来控制成员变量的操作，提高了代码的 安全性
• 把代码用方法进行封装，提高了代码的 复用性

this关键字:

• A:this:代表本类对象的引用
• B:局部变量和成员变量重名的时候使用

代码案例:

package com.itheima_07;
/*
 * 学生类
 *
 * 起名字我们要求做到见名知意。
 * 而我们现在的代码中的n和a就没有做到见名知意，所以我要改进。
 *
 * 如果有局部变量名和成员变量名相同，在局部使用的时候，采用的是就近的原则。
 *
 * 我们有没有办法把局部变量的name赋值给成员变量的name呢?
 * 有。
 *
 * 什么办法呢?
 *      用this关键字就可以解决这个问题
 *
 * this:代表所在类的对象引用
 *      方法被哪个对象调用，this就代表那个对象
 *
 * 使用场景：
 *      局部变量隐藏成员变量
 */
public class Student {
    private String name;
    private int age;

    public void setName(String name) { //"林青霞"
        //name = name;
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        //age = age;
        this.age = age;
    }

    public int getAge() {
        return age;
    }
}


package com.itheima_07;
/*
 * 学生类的测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        System.out.println(s.getName()+"---"+s.getAge());

        s.setName("林青霞");
        s.setAge(28);
        System.out.println(s.getName()+"---"+s.getAge());
    }
}

• 
  

面向对象之构造方法

构造方法: 主要用来给对象的数据进行初始化

构造方法格式:

• a:方法名与类名相同
• b:没有返回值类型，连void都没有

构造方法注意事项与重载:

• 如果你不提供构造方法，系统会给出默认构造方法
• 如果你提供了构造方法，系统将不再提供
• 构造方法也是可以重载的,重载条件和普通方法相同

代码示例:

package com.itheima_08;
/*
 * 构造方法：
 *      给对象的数据进行初始化
 *
 * 格式：
 *      方法名和类名相同
 *      没有返回值类型，连void都不能写
 *      没有具体的返回值
 *
 * 构造方法的注意事项：
 *      A:如果我们没有给出构造方法，系统将会提供一个默认的无参构造方法供我们使用。
 *      B:如果我们给出了构造方法，系统将不在提供默认的无参构造方法供我们使用。
 *        这个时候，如果我们想使用无参构造方法，就必须自己提供。
 *        推荐：自己给无参构造方法
 *      C:构造方法也是可以重载的
 *
 * 成员变量赋值：
 *      A:setXxx()方法
 *      B:带参构造方法
 */
public class Student {
    private String name;
    private int age;

    /*
    public Student() {
        System.out.println("这是构造方法");
    }
    */

    public Student() {}

    public Student(String name) {
        this.name = name;
    }

    public Student(int age) {
        this.age = age;
    }

    public Student(String name,int age) {
        this.name = name;
        this.age = age;
    }

    public void show() {
        System.out.println(name+"---"+age);
    }
}


package com.itheima_08;

public class StudentDemo {
    public static void main(String[] args) {
        //如何调用构造方法呢?
        //通过new关键字调用
        //格式：类名 对象名 = new 构造方法(...);
        Student s = new Student();
        s.show();

        //public Student(String name)
        Student s2 = new Student("林青霞");
        s2.show();

        //public Student(int age)
        Student s3 = new Student(28);
        s3.show();

        //public Student(String name,int age)
        Student s4 = new Student("林青霞",28);
        s4.show();
    }
}

• 
  
• 
  

类名作为形参和返回值

类名作为方法的形参：

package com.itheima_10;

public class Student {
    public void study() {
        System.out.println("好好学习,天天向上");
    }
}


package com.itheima_10;

public class Teacher {
    public void test(Student s) {//接收传递过来的Student对象的地址值
        s.study();                  
    }
}


package com.itheima_10;

//需求： 调用Teacher的test方法

//类名作为形式参数：其实这里需要的是该类对象。
public class Test {
    public static void main(String[] args) {
        Teacher t = new Teacher();
        Student s = new Student();
        t.test(s);
    }
}

• 
  

类名作为返回值:

package com.itheima_11;

public class Student {
    public void study() {
        System.out.println("好好学习,天天向上");
    }
}


package com.itheima_11;

public class Teacher {

    public Student getStudent() {
        Student s = new Student();
        return s;//返回的是Student对象的地址值
    }
}



package com.itheima_11;

//需求： 通过Teacher得到Student对象，然后调用Student类的方法
//如果方法的返回值是类名：其实返回的是该类的对象
public class Test {
    public static void main(String[] args) {
        Teacher t = new Teacher();
        Student s = t.getStudent();
        s.study();
    }
}

面向对象之继承

格式:

 class 子类 extends 父类{

 }

• 
  

重写与重载的区别

• 重写: 子类的方法与父类的方法声明完全一致，并且对方法体进行了重写。
• 重载: 方法的参数列表不同（参数类型，参数个数，参数的顺序） 方法名相同，与返回值无关。
• Override用于限定该方法必须是重写父类方法。

方法重写注意事项

• 访问权限:父类的全权限小于或等于子类的权限 默认的权限小于public的权限
• 返回类型相同
• 方法名相同
• 方法参数必须相同(特殊情况除外)

说明

• 子类的调用会优先调用父类的空参构造。
• super()决定了是否调用父类的空参构造。
• super()没有，系统会自动给上。
• 目的是为了给父类先进行初始化给子类使用。
• 本质上还是子类的构造方法先执行。

this和super

• This：代表是本类类型的对象引用。
• Super：代表是子类所属的父类中的内存空间引用。
• 局部>本类成员>父类成员
• super(参数) 调用父类的带参构造方法。
• 最终原则：先有父类内容，后有子类对象。

继承的注意事项

• 子类不能使用父类的私有方法和变量。
• 继承要合理

抽象类抽象方法

抽象类

• 描述: 只有功能声明，没有主体实现方法，一定是父类。
• 定义格式:

权限修饰 abstract class 类名{
  public abstract 返回值类型 方法名(){

  }
}

• 
  

注意

• 有抽象方法的类一定是抽象方法，反之不一定。
• 有抽象方法的类，不能被实例化，实例化没有意义。
• 只有覆盖了抽象类中所有的抽象方法后，其子类才可以创建对象。否则该子类还是一个抽象类。
• 抽象类的构造方法在子类中可以用super()调用，给类成员属性初始化。

抽象类构造

• 自身初始化 供子类使用

接口

定义格式

权限修饰 interface 类名{
  public abstract 返回值类型 方法名(){

  }
}

• 
  

接口中的成员特点

A:接口中可以定义变量，但是变量必须有固定的修饰符修饰，public static final 所以接口中的变量也称之为常量，其值不能改变。

B:接口中可以定义方法，方法也有固定的修饰符，public abstract

C:接口不可以创建对象。

D:子类必须覆盖掉接口中所有的抽象方法后，子类才可以实例化。否则子类是一个抽象类。

接口和抽象类的使用辨析

A:类继承类extends，只能单继承 
接口继承接口extends可以多继承 
类实现接口implements可以多实现 
接口不可以继承类

B:抽象类中可以有非抽象方法，有构造方法 
接口中全部为抽象方法，没构造方法

C:抽象类具有成员变量 
接口没有普通的成员变量

D:抽象类中的成员无固定修饰符 
接口中的成员有固定修饰符

多态

概念

• 父类(接口)引用变量可以指向子类对象,展现出父类(接口)的功能
• 子类引用变量可以指向子类对象,展现出子类的功能
• 子类对象可以表现出多种形态,这多种形态叫做多态

优点

• 大大提高了程序的扩展性
• 提高了程序的复用性

多态的定义与使用场景

• A:多态的定义格式：就是父类的引用变量指向子类对象 
  父类类型 变量名 = new 子类类型(); 
变量名.方法名();
• B:普通类多态定义的格式 
  父类 变量名 = new 子类();

class Fu {}
class Zi extends Fu {}
    //类的多态使用
Fu f = new Zi();

• 
  

• C:抽象类多态定义的格式 
  抽象类 变量名 = new 抽象类子类();

abstract class Fu {
         public abstract void method();
         }
class Zi extends Fu {
public void method(){
              System.out.println(“重写父类抽象方法”);
}
}
//类的多态使用
Fu fu= new Zi();

• 
  

• D:接口多态定义的格式 
  接口 变量名 = new 接口实现类();

 interface Fu {
             public abstract void method();
}
class Zi implements Fu {
             public void method(){
              System.out.println(“重写接口抽象方法”);
}
}
//接口的多态使用
Fu fu = new Zi();

• 
  

注意事项

• 当出现多态后,其调用的方法是类重写后的方法。

多态转型

多态的转型分为向上转型与向下转型两种： 
- A:向上转型：当有子类对象赋值给一个父类引用时，便是向上转型，多态本身就是向上转型的过程。

父类类型  变量名 = new 子类类型();
如：Person p = new Student();

• 
  

• B:向下转型：一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用转为子类引用，这个过程是向下转型。如果是直接创建父类对象，是无法向下转型的

子类类型 变量名 = (子类类型) 父类类型的变量;
如:Student stu = (Student) p;  //变量p 实际上指向Student对象






面向对象之异常处理


    异常：是在运行时期发生的不正常情况。

    在java中用类的形式对不正常情况进行了描述和封装对象。描述不正常的情况的类，就称为异常类。

    1. 以前正常流程代码和问题处理代码相结合，现在将正常流程代码和问题处理代码分离，提高阅读性。
    2. 其实异常就是java通过面向对象的思想将问题封装成了对象，用异常类对其进行描述。
    3. 不同的问题用不同的类进行具体的描述。比如角标越界、空指针异常等等。
    4. 问题很多，意味着描述的类也很多，将其共性进行向上抽取，形成了异常体系。

    不正常情况分成了两大类：
    Throwable：无论是error，还是异常、问题，问题发生就应该可以抛出，让调用者知道并处理。
    该体系的特点就在于Throwable及其所有的子类都具有可抛性。
    可抛性到底指的是什么呢？怎么体现可抛性呢？
    其实是通过两个关键字来体现的：throws throw，凡是可以被这两个关键字所操作的类和对象都具备可抛性。

    1. 一般不可处理的：Error
       特点：是由jvm抛出的严重性问题。
       这种问题发生，一般不针对性处理，直接修改程序。
    2. 可以处理的：Exception

    该体系的特点：
    子类的后缀名都是用其父类名作为后缀，阅读性很强。

    Throwable中的方法：
    1. getMessage()：获取异常信息，返回字符串。
    2. toString()：获取异常类名和异常信息，返回字符串。
    3. printStackTrace()：获取异常类名和异常信息，以及异常出现在程序中的位置，返回值void。
    4. printStackTrace(PrintStream s)：通常用该方法将异常内容保存在日志文件中，以便查阅。

    示例：class Demo{
       public static int method(int[] arr, int index){
             if(arr == null){
                   throw new NullPointerException("数组的引用不能为空！");
             }
             if(index >= arr.length ){
                   throw new ArrayIndexOutOfBoundsException("数组的角标越界：" + index);
             }
             return arr[index];
       }
}
class ExceptionDemo{
       public static void main(String[] args){
            int[] arr = new int[3];
            Demo.method(arr,30);
       }
}

   运行结果：

    4.10.2 自定义异常

    可以自定义出的问题称为自定义异常。
    对于角标为负数的情况，可以用负数角标异常来表示，负数角标这种异常在java中并没有定义过。
    那就按照java异常的创建思想，面向对象，将负数角标进行自定义描述，并封装成对象。
    这种自定义的问题描述称为自定义异常。

    P.S.
    如果让一个类成为异常类，必须要继承异常体系，因为只有成为异常体系的子类才有资格具备可抛性，才可以被两个关键字所操作：throws、throw。

    自定义类继承Exception或者其子类，通过构造函数定义异常信息。

    示例：
Class DemoException extends Exception
{
     DemoException(String message)
     {
          super(message);
     }
}
   
    通过throw将自定义异常抛出。

    throws和throw的区别：
    1. throws用于标识函数暴露出的异常类，并且可以抛出多个，用逗号分隔。throw用于抛出异常对象。
    2. thorws用在函数上，后面跟异常类名。throw用在函数内，后面跟异常对象。

    定义功能方法时，需要把出现的问题暴露出来让调用者去处理，那么就通过throws在函数上标识。
    在功能方法内部出现某种情况，程序不能继续运行，需要进行跳转时，就用throw把异常对象抛出。

    示例：
class FuShuIndexException extends Exception{
      FuShuIndexException(){}

      FuShuIndexException(String msg){
             super(msg);
      }
}

class Demo{
       public static int method(int[] arr, int index) throws FuShuIndexException{
             if(index < 0){
                   throw new FuShuIndexException("数组的角标是负数啦！" );
             }
             return arr[index];
       }
}

class ExceptionDemo{
       public static void main(String[] args) throws FuShuIndexException{
            int[] arr = new int[3];
            Demo.method(arr,-30);
       }
}
   运行结果：


    异常的分类：
    1. 编译时被检测异常：只要是Exception和其子类都是，除了特殊子类RuntimeException体系。
        这种问题一旦出现，希望在编译时就进行检测，让这种问题有对应的处理方式。
        这样的问题都可以针对性的处理。

    2. 编译时不检测异常（运行时异常）：就是Exception中的RuntimeException和其子类。
        这种问题的发生，无法让功能继续，运算无法运行，更多是因为调用的原因导致的或者引发了内部状态的改变导致的。
        那么这种问题一般不处理，直接编译通过，在运行时，让调用者调用时的程序强制停止，让调用者对代码进行调整。
        所以自定义异常时，要么继承Exception，要么继承RuntimeException。

    示例：
class FuShuIndexException extends RuntimeException{
      FuShuIndexException(){}

      FuShuIndexException(String msg){
             super(msg);
      }
}

class Demo{
       public static int method(int[] arr, int index){//RuntimeException没有必要用throws抛出，并不是必须要处理
             if(index < 0){
                   throw new FuShuIndexException("数组的角标是负数啦！" );
             }
             return arr[index];
       }
}
   运行结果：


    P.S.
    RuntimeException是那些可能在Java虚拟机正常运行期间抛出的异常的超类。
    可能在执行方法期间抛出但未被捕获的RuntimeException的任何子类都无需在throws子句中进行声明。

    异常处理的捕捉形式：
    可以对异常进行针对性处理的方式。

    具体格式是：
    try{
         //需要被检测异常的代码。
    }
    catch(异常类 变量) //该变量用于接收发生的异常对象
    {
         //处理异常的代码。
    }
    finally{
         //一定会执行的代码；在return前执行
    }

    P.S.
    finally代码块只有一种情况不会被执行，就是在之前执行了System.exit(0)。

    处理过程：
    try中检测到异常会将异常对象传递给catch，catch捕获到异常进行处理。
    finally里通常用来关闭资源。比如：数据库资源，IO资源等。
    需要注意：try是一个独立的代码块，在其中定义的变量只在该变量块中有效。
    如果在try以外继续使用，需要在try外建立引用，在try中对其进行初始化。IO，Socket就会遇到。

    示例：
class FuShuIndexException extends RuntimeException{
      FuShuIndexException(){}

      FuShuIndexException(String msg){
             super(msg);
      }
}

class Demo{
       public static int method(int[] arr, int index) throws NullPointerException,FuShuIndexException{
             if(arr == null)
                   throw new NullPointerException("没有任何数组实体");
             if(index < 0){
                   throw new FuShuIndexException("数组的角标是负数啦！");
            }
             return arr[index];
      }
}

class ExceptionDemo{
       public static void main(String[] args){
            int[] arr = new int[3];
            try{
                  int num = Demo.method(arr,-30);
                  System.out.println("num:" + num);
            } catch(NullPointerException e){
                  System.out.println(e);
            } catch(FuShuIndexException e){
                  System. out.println("message:" + e.getMessage());
                  System.out.println("string:" + e);
                  e.printStackTrace(); //jvm 默认的异常处理机制就是调用异常对象的这个方法。
                  System.out.println("负数角标异常！！！");
            } catch(Exception e){//Exception的catch放在最下面，先处理有针对性的异常
                  System.out.println(e);
            }
            System.out.println("over" );
      }
}

    运行结果：

 

    异常处理的原则：
    1. 函数内容如果抛出需要检测的异常，那么函数上必须要声明。
        否则，必须在函数内用try/catch捕捉，否则编译失败。

    2. 如果调用到了声明异常的函数，要么try/catch，要么throws，否则编译失败。

    3. 什么时候catch，什么时候throws呢？
        功能内容可以解决，用catch。
        解决不了，用throws告诉调用者，由调用者解决。

    4. 一个功能如果抛出了多个异常，那么调用时，必须有对应多个catch进行针对性处理。
       内部有几个需要检测的异常，就抛几个异常，抛出几个，就catch几个。

    示例：
class Demo{
       public int show(int index) throws ArrayIndexOutOfBoundsException{
             if(index < 0)
                   throw new ArrayIndexOutOfBoundsException("越界啦！");
             int[] arr = new int[3];
             return arr[index];
       }
}

class ExceptionDemo{
       public static void main(String[] args){
            Demo d = new Demo();
            try{
                  int num = d.show(-3);
                  System.out.println("num = " + num);
             } catch(ArrayIndexOutOfBoundsException e){
                  System.out.println(e.toString());
                  System.exit(0);//退出jvm
             } finally{//通常用于关闭（释放）资源
                  System.out.println("finally");//由于前面执行了System.exit(0);，故不会执行此语句。
             }
            System.out.println("over");
      }
}
   运行结果：


    try catch finally 代码块组合特点：
    1. try catch finally
    2. try catch(多个)：当没有资源需要释放时，可以不用定义finally。
    3. try finally：异常无法直接catch处理，但是资源必须关闭。

    示例：
void show() throws Exception{
     try{
          //开启资源
          throw new Exception();
      }finally{
          //关闭资源
      }
}

    异常综合案例：/*
毕老师用电脑上课。

问题领域中涉及两个对象。
毕老师，电脑。

分析其中的问题。
比如电脑蓝屏，冒烟等。
*/
class LanPingException extends Exception{
      LanPingException(String msg){
             super(msg);
      }
}

class MaoYanException extends Exception{
      MaoYanException(String msg){
             super(msg);
      }
}

class NoPlanException extends Exception{
      NoPlanException(String msg){
             super(msg);
      }
}

class Computer{
       private int state = 1;//0 2
       public void run() throws LanPingException,MaoYanException{
             if(state == 1)
                   throw new LanPingException("电脑蓝屏啦！");
             if(state == 2)
                   throw new MaoYanException("电脑冒烟啦！");
             System. out.println("电脑运行");
       }
       public void reset(){
            state = 0;
            System.out.println("电脑重启");
       }
}

class Teacher{
       private String name ;
       private Computer comp ;

       Teacher(String name){
             this.name = name;
             comp = new Computer();
       }

       public void prelect() throws NoPlanException{
             try{
                  comp.run();
                  System. out.println(name + "讲课");
             } catch(LanPingException e){
                  System.out.println(e.toString());
                  comp.reset();
                  prelect();
             } catch(MaoYanException e){
                  System. out.println(e.toString());
                  test();
                   //可以对电脑进行维修
                   throw new NoPlanException("课时进度无法完成，原因：" + e.getMessage());
             }
       }
       public void test(){
            System.out.println("大家练习");
       }
}

class ExceptionDemo{
       public static void main(String[] args){
            Teacher t = new Teacher("毕老师");
             try{
                  t.prelect();
             } catch(NoPlanException e){
                  System.out.println(e.toString() + "......." );
                  System.out.println("换人");
             }
       }
}

   运行结果：


    异常的注意事项：    
    1. RuntimeException以及其子类如果在函数中被throw抛出，可以不用在函数上声明。
    2. 子类在覆盖父类方法时，父类的方法如果抛出了异常，那么子类的方法只能抛出父类的异常或者该异常的子类。
    3. 如果父类抛出多个异常，那么子类只能抛出父类异常的子集。
    简单说：子类覆盖父类只能抛出父类的异常或者子类的子集。

    P.S.
    如果父类的方法没有抛出异常，那么子类覆盖时绝对不能抛，就只能try。

4.11 Object类
    Object：所有类的根类。
    Object是不断抽取而来，具备着所有对象都具备的共性内容。

    示例：
class Person{
      private int age ;
      Person(int age){
             this.age = age;
      }
}

class Demo{
}

class ObjectDemo{
       public static void main(String[] args){
            Person p1 = new Person(20);
            Person p2 = new Person(20);
            Person p3 = p1;
      
            Demo d = new Demo();

            System. out.println(p1 == p2);//false
            System. out.println(p1.equals(p2));//false
            System. out.println(p1.equals(p3));//true
            System. out.println(p1.equals(d));//false
      }
}

   运行结果：

    P.S.
    ==以及Object类的equals方法默认都是根据对象的哈希值判断两个对象是否相等。
    可以通过覆盖Object的equals方法来重写比较规则。

    示例：
class Person{
       private int age ;
       Person( int age){
             this.age = age;
       }
       //比较Person的年龄，是否是同龄人
       //一般都会覆盖此方法，根据对象的特有内容，建立判断对象是否相同的依据。
       public boolean equals(Object obj){
             if(!(obj instanceof Person))
                   throw new ClassCastException("类型错误");
             Person p = (Person)obj;
             return this .age == p.age;
      }
}

class ObjectDemo{
       public static void main(String[] args){
            Person p1 = new Person(20);
            Person p2 = new Person(20);

            System. out.println(p1.equals(p2));
      }
}

   运行结果：

    Object类的toString方法默认返回的内容是“对象所属的类名+@+对象的哈希值（十六进制）”。

    示例：
class Person{
      private int age ;
      Person(int age){
             this.age = age;
      }
      public int hashCode(){
             return age ;
      }
}

class ObjectDemo{
       public static void main(String[] args){
            Person p1 = new Person(20);

            System. out.println(p1);
            System. out.println(p1.getClass().getName() + " $ " + Integer.toHexString(p1.hashCode()));
      }
}

   运行结果：