11.多态

1.多态：同一个对象拥有不同的形态。

2.先引出一个例子。

package com.itppf.dao;

public class Noodle {
    public void cook(){
        System.out.println("做一碗面条！");
    }
}

package com.itppf.dao;

public class Rice {
    public void cook(){
        System.out.println("做一碗米饭！");

    }
    }

package com.itppf.dao;

public class Cookier {
    public void cook(Noodle n){
        n.cook();
    }
    public void cook(Rice r){
        r.cook();
    }
}

然后创建做饭的场景。

package com.itppf.dao;

public class Client {
    public static void main(String[] args) {
        Noodle n=new Noodle();
        Rice r=new Rice();

        Cookier c=new Cookier();//new一个厨师
        c.cook(n);//让厨师做面条
        c.cook(r);//让厨师做米饭
    }
}

3.由上面的例子可知，无论是做米饭还是做面条都需要创建不同的方法，这样以来就十分繁琐，那么我们有没有方法能简化这一步操作呢？

答案是可以的，我们可以定义一个食物类，面条和米饭同属于食物。

为了更直观体现，再新建一个soup类

package com.itppf.dao;

public class Noodle extends  Food{
    public void cook(){
        System.out.println("做一碗面条！");
    }
}

package com.itppf.dao;

public class Rice extends Food{
    public void cook(){
        System.out.println("做一碗米饭！");
    }
    }

package com.itppf.dao;

public class Soup extends Food {
    public void cook(){
        System.out.println("做一碗汤！");
    }
}

然后创建食物类

package com.itppf.dao;

public class Food {
public void cook(){
    System.out.println("烹饪食物");//主要使用cook方法，这里写不写都行
}
}

创建厨师类

package com.itppf.dao;

public class Cookier{
//    public void cook(Noodle n){
//        n.cook();
//    }
//    public void cook(Rice r){
//        r.cook();
//    }
public void cook(Food food){     //接收传进来的食物类型，也就是接收实例化的食物值，然后让不同的食物去实现各自的方法。
    food.cook();
}
}

创建做饭的场景

package com.itppf.dao;

public class Client {
    public static void main(String[] args) {
//        Noodle n=new Noodle();
//        Rice r=new Rice();
//
//        Cookier c=new Cookier();//new一个厨师
//        c.cook(n);//让厨师做面条
//        c.cook(r);//让厨师做米饭
        Food food1=new Noodle();   //把面条、米饭、汤当做食物来看，把子类的对象赋值给父类的引用，向上转型。向下转型
                                     //Noodle noodle=(Noodle)food1 强制转型、
        Food food2=new Rice();
        Food food3=new Soup();

        Cookier cookier=new Cookier();     
        cookier.cook(food1);
        cookier.cook(food2);
        cookier.cook(food3);

    }
}

练习：

4.根据类图，写游戏代练，其实和上面的例子一样，就是看你方法里面写什么。

//先根据UML图写出Game类
package com.itppf.entity;

public class Game {
    public void start(){
        System.out.println("开始游戏");
    }
    public void play(){
        System.out.println("开始进入游戏");
    }
    public void end(){
        System.out.println("结束游戏");
    }
}


//LOL
package com.itppf.entity;

public class LOL extends Game {
    public void play(){
        System.out.println("开始玩LOL！");
    }
}


//DNF
package com.itppf.entity;

public class DNF extends Game {
    public void play(){
        System.out.println("开始玩DNF！");

    }
}


//CS
package com.itppf.entity;

public class CS extends Game {
    public void play(){
        System.out.println("开始玩CS！");

    }
}



//玩家
package com.itppf.entity;

public class Player{
    public void happy(Game game){
        game.play();
    }
}


//游戏场景
package com.itppf.entity;

public class GameClient {
    public static void main(String[] args) {
        Game game1=new DNF();
        Game game2=new LOL();
        Game game3=new CS();


        Player player=new Player();
        player.happy(game1);
        player.happy(game2);
        player.happy(game3);

    }
}

12.final关键字

1.final：被final修饰的变量不可以被改变（无论是成员变量还是局部变量都不可改变），最终的，最后的，不可以被改变的。

2.被final修饰的方法不能够重写。

3.被final修饰的类不可以被继承。

举个例子

package com.itppf.entity;

public class Car {
    
    public final void type(){

        System.out.println("你的车是什么类型啊！");
    }
    
}

13.抽象

1.在java中：只声明，不实现。

2.abstract修饰方法，这个方法就是一个抽象方法，抽象方法没有方法体。

3.类中如果有个抽象方法，这个类必须是一个抽象类，否则会报错。

4.抽象类的特点：

5.不可以创建对象，没有实例，不存在的东西。

6.抽象类的子类，必须重写父类中的抽象方法。

7.简单说明一下，抽象类继承父类的时候，由于父类中的方法是抽象方法，所以子类中的方法也是抽象方法，这时要求子类重写父类的方法才能够实现实例化。

注：父类是抽象类，子类不一定是抽象类。

如何让它不报错？

必须重写父类的方法。

重写之后不报错。

8.作用:通过抽象类可以强制要求子类中必须有哪些方法。

添加一个抽象方法shape()后，子类必须重写这个方法，否则会报错。

重写之后。

抽象类更多的是规范化的作用，在父类中定义抽象方法，然后在子类中必须去重写这些方法，然后利用多态性进行操作。

EG:1.抽象化的父类

package com.itppf.entity;

public abstract class Fruit {
    public abstract void type();
    public abstract  void color();
}

2.两个子类继承父类并且重写方法。

package com.itppf.entity;

public class Peach extends Fruit{
    public void type(){
        System.out.println("这个水果的名字叫桃子！");
    }
    public void color(){
        System.out.println("这个苹果的颜色是红色的！");
    }
}

package com.itppf.entity;

public class Apple extends Fruit{
    public void type(){
        System.out.println("这个水果的名字叫苹果！");
    }
    public void color(){
        System.out.println("这个苹果的颜色是红色的！");
    }
}

3.售卖者

package com.itppf.entity;

public class Saler {
    public void sale(Fruit fruit){          //这里接收参数，并且调用各自类中的方法。
       fruit.type();          
       fruit.color();
    }
}

4.售卖场景

package com.itppf.entity;

public class FruitClient {
    public static void main(String[] args) {
        Fruit fruit1=new Apple();
        Fruit fruit2=new Peach();

        Saler saler1=new Saler();
        saler1.sale(fruit1);        //这里将苹果的参数传到售卖者那里。
        System.out.println("*******************");
        saler1.sale(fruit2);               //这里将桃子的参数传到售卖者那里。
    }
}

8.注意：抽象类中可以添加别的方法,类似于

package com.itppf.entity;

public abstract class Fruit {
    public abstract void type();
    public abstract  void color();
    public void weight(){
        System.out.println("这个水果很重！");
    }
}

14.接口

1.接口是一种特殊的抽象类。

2.接口中所有的方法都是抽象方法，省略掉abstract。

3.接口使用interface来声明。

4.接口中的方法都是公开的，公共的。

5.能继承接口的只能是接口。

6.接口和类只能是实现关系。

笔记记到这里，学了抽象类之后突然明白了接口存在的意义。总结一下，就是标准化、规范化地定义一个东西，人人都能拿到接口去做自己的东西。

package com.itppf.dao;

public interface place {
    public abstract void point();
}

package com.itppf.dao;

public class home implements place {
    public void point(){                 //必须要实现接口方法，其实就是重写。

    }
}

继承和接口用法几乎差不多，接口也具有多态性。

接口可以把不相关的东西进行整合。

注：类只能单继承，但接口可以多实现。

注：接口里面的变量都是全局静态变量。

在接口里面定义了面积，然后去调用会报错。

在HomeTest中调用会报错。

因为被隐藏到的是

    public static final int area=100;

这样可以打印出来

   System.out.println(home1.area);

这个例子可以比较形象地展现接口。

package com.itppf.dao;

public interface Country {
    public abstract void specificcountry();
}

package com.itppf.dao;

public  interface Province {
    public abstract void specificprovince();
}

package com.itppf.dao;

public interface Area {

    public abstract void specificsize();
}

package com.itppf.dao;

public interface Type {
    public abstract void specifictype();
}

package com.itppf.dao;

public class Place {
    public  void specificplace(){
        System.out.println("你家具体在哪个地方？");
    }
}

package com.itppf.dao;
//单继承，多实现。
public class Home extends Place implements Country,Province,Area,Type{  
//类可以实现多个接口，而接口也可以被多个接口继承。
//这里要讲，你的家不仅仅在这个国家里面，而且在这个城市里面，或者定义大小，你家有多大？多态性的体现。
//重写了一个继承的父类和三个接口，一个是展示你居住地的省份，一个是国家，还有一个是居住面积。
    @Override        //表示这个方法是重写的
    public void specificplace() {
//        super.specificplace(); //super调用的是父类的方法。
        System.out.println("你家居住的具体位置在哪里？");
    }

    @Override
    public void specificsize() {
        System.out.println("你家的居住面积多大？");
    }

    @Override
    public void specificprovince() {
        System.out.println("你家居住在哪个省份？");
    }

    @Override
    public void specificcountry() {
        System.out.println("你家居住在哪个国家？");
    }
    @Override
    public void specifictype() {
        System.out.println("你家是什么建筑风格？");
    }

}

package com.itppf.dao;

public class HomeTest {
    public static void main(String[] args) {
//        Home home1=new Home();
//        home1.specificpoint();

         Home home1=new Home(); //从家的方面去看我家，创建对象“hom1”；
         Type home2=new Home(); //从件筑风格的方面去看我家，创建对象“hom2”；（向上转型）
         Area home3=new Home();  //从建筑面积的方面去看我家，创建对象“hom3”； （向上转型）
        Province home4=new Home();  //从哪个省的方面去看我家，创建对象“hom4”； （向上转型）
        Country home5=new Home(); //从哪个国家的方面去看我家，创建对象“hom1”；（向上转型）

        //以上很好地展现出了java的多态性。

        System.out.println("-----从家的方面去调用home1具体实例-----");
        home1.specificplace();
        home1.specifictype();
        home1.specificsize();
        home1.specificprovince();
        home1.specificcountry();
        System.out.println("*******");

        System.out.println("-----从建筑风格的方面去调用home2具体实例-----");
//        home2.specificplace();
        home2.specifictype();
//        home2.specificsize();
//        home2.specificprovince();
//        home2.specificcountry();
//    由上可知，在建筑风格的角度去调用，只能看到家里建筑风格，大小，国家，省份看不到
        System.out.println("*******");


        System.out.println("-----从建筑大小的方面去调用home3具体实例-----");
//        home3.specificplace();
//        home3.specifictype();
        home3.specificsize();
//        home3.specificprovince();
//        home3.specificcountry();
//    由上可知，在建筑大小的角度去调用，只能看到家里建筑大小，风格，国家，省份看不到
        System.out.println("*******");


        System.out.println("-----从居住省份的方面去调用home4具体实例-----");
//        home4.specificplace();
//        home4.specifictype();
//        home4.specificsize();
       home4.specificprovince();
//        home4.specificcountry();
//    由上可知，在居住省份的角度去调用，只能看到家里居住的省份，大小，国家，建筑风格看不到
        System.out.println("*******");
        System.out.println("*     *");
        System.out.println("*     *");
        System.out.println("*******");


        System.out.println("-----从居住国家的方面去调用home5具体实例-----");
//        home5.specificplace();
//        home5.specifictype();
//        home5.specificsize();
//        home5.specificprovince();
        home5.specificcountry();
//    由上可知，在居住国家的角度去调用，只能看到家里居住的国家，大小，风格，省份看不到
        System.out.println("*******");




    }
}

接口练习

综合以上，方案二比较好，类如果都实现了接口方法，则是实现类，否则都是抽象类。

方案一：

package com.itppf.dao;

public interface IDAO {
    public abstract void connect();
    public abstract void add();
    public abstract void del();
    public abstract  void upd();
    public abstract void sel();

}

package com.itppf.dao;

public class MysqlDAO implements IDAO{

    @Override
    public void connect() {
        System.out.println("连接mysql");
    }

    @Override
    public void add() {
        System.out.println("增加数据");
    }

    @Override
    public void del() {
        System.out.println("删除数据");
    }

    @Override
    public void upd() {
        System.out.println("更新数据");
    }

    @Override
    public void sel() {
        System.out.println("查询数据");
    }
}

package com.itppf.dao;

public class OrcaleDAO implements IDAO{
    @Override
    public void connect() {
        System.out.println("连接Orcale");
    }

    @Override
    public void add() {
        System.out.println("增加数据");
    }

    @Override
    public void del() {
        System.out.println("删除数据");
    }

    @Override
    public void upd() {
        System.out.println("更新数据");
    }

    @Override
    public void sel() {
        System.out.println("查询数据");
    }
}

package com.itppf.dao;

import com.sun.org.apache.xpath.internal.operations.Or;

import java.util.Scanner;

public class FirstClient {
    public static void main(String[] args) {
        System.out.println("你想要连接哪一个数据库");
        Scanner scanner=new Scanner(System.in);
        int n=scanner.nextInt();
        if(n==1){
           IDAO idao=new MysqlDAO();
           idao.connect();
           idao.add();
           idao.del();
           idao.upd();
           idao.sel();
        }else if(n==2){
            IDAO idao=new OrcaleDAO();
            idao.connect();
            idao.add();
            idao.del();
            idao.upd();
            idao.sel();
        }


    }
}

以上方案一可以看得出程序代码的复用性很差。

方案二：

package com.itppf.entity;

public interface IDAO {
    public abstract void connect();
    public abstract void  add();
    public  abstract  void  del();
    public  abstract  void upd();
    public  abstract  void sel();
}

package com.itppf.entity;

public  abstract class AbstractDAO implements IDAO {
    @Override
    public void add() {
        System.out.println("增加数据");
    }

    @Override
    public void del() {
        System.out.println("删除数据");
    }

    @Override
    public void upd() {
        System.out.println("更新数据");
    }

    @Override
    public void sel() {
        System.out.println("查询数据");
    }
}

package com.itppf.entity;

public class MysqlDAO extends AbstractDAO {
    @Override
    public void connect(){
        System.out.println("连接mysql数据库！");
    }
}

package com.itppf.entity;

public class OrcaleDAO extends AbstractDAO{
    @Override
    public void connect() {
        System.out.println("连接orcale数据库！");
    }
}

package com.itppf.entity;

import com.sun.xml.internal.bind.v2.model.core.ID;

import java.util.Scanner;

public class ScondClient  {
    public static void main(String[] args) {
        System.out.println("你想连接哪个数据库？1-mysql 2-orcale");
        Scanner scanner=new Scanner(System.in);
        int n=scanner.nextInt();
        //全局声明
        IDAO idao=null;
        if(n==1){
             idao=new MysqlDAO();
        }else if(n==2){
              idao=new OrcaleDAO();
        }
        idao.connect();
        idao.add();
        idao.del();
        idao.upd();
        idao.sel();
    }
}

方案二则是将公有的方法从接口里面抽出来，形成一个抽象类，然后子类继承父类并且将不同的部分进行重写。

注：java接口可以被继承,而且是多继承,但是只能是接口继承接口,类只能实现接口。一个接口可以继承另一个接口或多个,一个普通类可以实现多个接口。

15.成员变量初始值

1.java中的变量必须先声明，再赋值，最后才能使用。

2.java中的成员变量，在创建对象的时候，都会执行一次初始化的操作，默认一个初始值。

3.基本数据类型默认值都是0，引用数据类型默认值都是null，null表示的是占位符。

public class InitialValue {
    byte b;
    float f;
    double d;
    int i;
    char c;
    boolean bool;
    short s;
    long l;

    String str;
    InitialValue inital;
}

public class InitialTest {
    public static void main(String[] args) {
        InitialValue i=new InitialValue();
        System.out.println("byte="+i.b);
        System.out.println("float="+i.f);
        System.out.println("double="+i.d);
        System.out.println("int="+i.i);
        System.out.println("char="+i.c);
        System.out.println("boolean="+i.bool);
        System.out.println("short="+i.s);
        System.out.println("long="+i.l);
        System.out.println("String="+i.str);
        System.out.println("InitialValue="+i.inital);
    }
}

16.object

1.object是基类，任何类都要继承自它。

2.我们写的类，即使不继承自父类，也会继承自它。继承的父类也是object的子类。

17.equals和==

1.==判断左右的数据是否相等。

2.object类提供的一种方法，判断两个对象是否相等。

public class Cow {
    String name;
    String color;
    int age;
    public Cow(String name,String color,int age){
        this.name=name;
        this.color=color;
        this.age=age;
    }

    public static void main(String[] args) {
        Cow cow1=new Cow("小黄","黄色",12);
        Cow cow2=new Cow("小黄","黄色",12);


        System.out.println(cow1==cow2);
        System.out.println(cow1.equals(cow2));
    }
}

输出：
false
false

3."=="一般默认基本数据类型是否相等，判断两个内存的地址是否一致，这里new开辟了新空间，所以肯定不一致。

4."equals"默认是object提供的方法。

public class Cow {
    String name;
    String color;
    int age;
    public Cow(String name,String color,int age){
        this.name=name;
        this.color=color;
        this.age=age;
    }
     public boolean equals(Cow cow){
     if(this.name==cow.name && this.color==cow.color){
         return true;
     }else{
         return false;
     }
}
    public static void main(String[] args) {
        Cow cow1=new Cow("小黄","黄色",12);
        Cow cow2=new Cow("小黄","黄色",12);


//        System.out.println(cow1==cow2);
        System.out.println(cow1.equals(cow2));
    }
}

输出:
true

5.上面代码中的"equals"是子类对于父类object方法的不满，然后行的扩展，然后进行重写。

  if(this.name==cow.name && this.color==cow.color){   //这句中的条件可以写一个两个或者全部。

EG：举个例子，cow1和cow2只有名字一样其余都不一样，然后根据name判断是否相等？

public class Cow {
    String name;
    String color;
    int age;
    public Cow(String name,String color,int age){
        this.name=name;
        this.color=color;
        this.age=age;
    }
     public boolean equals(Cow cow){
     if(this.name==cow.name){
         return true;
     }else{
         return false;
     }
}
    public static void main(String[] args) {
        Cow cow1=new Cow("小黄","黑色",11);
        Cow cow2=new Cow("小黄","黄色",12);


//        System.out.println(cow1==cow2);
        System.out.println(cow1.equals(cow2));
    }
}

输出：
true

6.说明equals很灵活，纵使颜色和年龄都不同，然后根据name相等依然可以得出两者相同。

7.同理，只有年龄不同，依然可根据name&&color得出相同。

经典案例一：

package com.itppf;

public class Tiger {
    public static void main(String[] args) {
        String str1="老虎";
        String str2="老虎";
        System.out.println(str1==str2);
        System.out.println(str1.equals(str2));

    }
}

输出：
true;
true;

这里str1开辟了内存地址，str2发现一样后也指向了“老虎”。

经典案例二：

package com.itppf;

public class Tiger {
    public static void main(String[] args) {
       String str3=new String("老虎");
        String str4=new String("老虎");

        System.out.println(str3==str4);
        System.out.println(str3.equals(str4));
    }
}

输出：
false；//new String来引入（”老虎“），是不同的对象。
true；//两个字符串的内容是一致的。

练习模拟登陆。

import java.util.Scanner;

public class Login {

    public static void main(String[] args) {
        String username="admin";
        String userpassword="admin";
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入用户名：");

        String uname=scanner.nextLine();
        System.out.println("请输入密码：");

        String upassword=scanner.nextLine();

        if (uname.equals(username) && userpassword.equals(upassword) ){
            System.out.println("登陆成功");
        }else{
            System.out.println("登录失败");
        }

    }
}

这里涉及到一个问题，扫描仪调用的next()、nextInt()、nextLine()到底有什么区别？

1.他们的区别在于对于空格的处理方式不同，以及返回值不同。

2.使用nextLine()方法时，不将空格看做是两个字符串的间隔，而是看作字符串的一部分，返回时，它作为String类型一并返回。

3.使用next()方法时，将空格看作是两个字符串的间隔。

4.使用nextInt()方法时，与next()方法类似，只是它的返回值是int类型的，依旧将空格看作是两个输入的数据的间隔。

18.toString

1.toString()对一个对象字符串的表现形式。

2.java中建议对toString()方法进行重写，原本默认是方法是包名+类名+内存地址。

直接赋值：

package com.itppf.entity;

public class Dog {
    String name="小黄";        
    String color="绿色";
    int age=13;

    public static void main(String[] args) {
        Dog dog1=new Dog();
        System.out.println(dog1);
        System.out.println(dog1.toString());
    }
}

突然我在这里意识到了一个问题，那就是：

直接赋值和使用构造方法有什么区别？

直接赋值内存地址和值都相同，构造方法赋值，内存地址不同，值同。直接赋值比较耗费内存，而使用构造方法可以起到懒加载的作用，创建对象后开始赋值。

使用构造方法：

package com.itppf.entity;

public class Dog {
 String name;
    String cllor;
    int age;

    public Dog(String name,String color,int age){
        this.name=name;
        this.cllor=color;
        this.age=age;
    }

    @Override
    public String toString() {                      //这是idea提供的自动重写方法。
        return "Dog{" +
                "name='" + name + '\'' +
                ", cllor='" + color + '\'' +
                ", age=" + age +
                '}';
    }

  //public String toString(){                       这是我重写的构造方法。
   //    return "我的狗的名字叫："+this.name+"我的狗的颜色是："+this.color+"年龄:"+this.age;
    //}

    public static void main(String[] args) {
        Dog dog2=new Dog("小黄","黄色",13);
        System.out.println(dog2.toString());
    }
            }

这是idea提供的自动重写方法。

这是我重写的构造方法。

19.instanceof关键字

1.主要判断对象属于哪种类型的。

package com.itppf.entity;

public class Mouse extends Animal {
    public static void main(String[] args) {
 Animal animal=new Mouse();
//Animal animal=new Animal();这不是老鼠。
 if(animal instanceof Mouse){
     System.out.println("这是一只老鼠");
        }else{
     System.out.println("这不是老鼠");
 }

    }
}

20.参数传递的问题

1.值传递（java中就是值传递）。

2.引用传递。

package com.itppf.entity;

public class ChairTest {
    public static void chang(Chair chair){
       chair=new Chair("长椅子");
    }

    public static void main(String[] args) {
        Chair chair=new Chair("短椅子");
        chang(chair);
        System.out.println(chair.name);
    }
}
输出：
短椅子

package com.itppf.entity;

public class ChairTest {
    public static void chang(Chair chair){
        chair.name="长椅子";
    }

    public static void main(String[] args) {
        Chair chair=new Chair("短椅子");
        chang(chair);
        System.out.println(chair.name);
    }
}
输出：
短椅子

这里使用到了内存分析，需要画图分析。

总结：面向对象，上帝视角，把控全局。

1.类与对象：对象操作程序，类创建对象，类与对象就是对数据的封装。

2.构造：给对象设置属性值，出厂化的设置、（this表示当前类的对象，拿到这个对象内容、访问构造方法。super 调用自己类中父类的内容，子类和父类中重名的内容可以区分，调用父类的构造方法）。

3.访问权限：

4.继承：父类有的功能，子类可以进行扩展，简化开发。

5.多态：同一个对象有不同的形态，你可以是儿子，可以是爸爸，可以是弟弟。

6.抽象：abstract，抽象方法可以不写方法体，抽象类可以写抽象方法也可以写正常的方法，对子类的约束，必须重写抽象类中的抽象方法。

7.接口：特殊的抽象类，interface。能继承接口的必须是接口。类可实现接口，一个类可以实现多个接口，为了弥补java不能多继承，java可以多实现。

8.内存分析：

21.异常处理

编译异常：语法错误，编码错误。

1.运行异常：编译的时候是没有错误的，语法方面是绝对正确的，找的就是运行时候的错误。

2.抛异常：发现错误的时候，会创建一个错误的对象对错误进行收集，丢出错误对象的过程叫抛异常。

3.捕获异常：默认由JVM来捕获异常，对错误信息进行打印，JVM会终止程序的进行。

1.异常的分类：

Throwable是所有异常的根，所有的异常都继承自Throwable，类似于Object。

Error：系统级的错误。

RuntimeExpection：运行异常，不手动处理，出问题了处理，例子（车爆胎）。

其他Exception：必须要经过手动处理，例子（路障）。

2.异常处理try...catch

语法：

try{
尝试执行的代码;
}catch(Exception e){                      //catch抓住,Exception类型的e来接收异常。
处理异常的代码;
}finally                                 //无论是否出错，都要finally  

举个例子

package com.itppf.entity;

public class YcTest {
    public static void main(String[] args) {
     try{
         System.out.println(1/0);
     }catch (Exception e){
         e.printStackTrace();   //打印出错误，面向程序员。
         System.out.println("程序出错了！"); //面向用户
     }finally{
         System.out.println("执行finally");
     }
    }
}

如果程序是对的呢？

finally：很有用，代码没有错，可以使用finally看到。

使用finally关闭文件，否则文件始终处于打开状态。

3.异常处理throws和throw

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;

public class FileTest {
   public static void read(){
       InputStream inputStream=new FileInputStream(new File("hello,world!"));
   }
}

第一种：try...catch

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;

public class FileTest {
   public static void read(){
       try{
           InputStream inputStream=new FileInputStream(new File("hello,world!"));
       }catch (Exception e){
           System.out.println("出错");
       }finally{
           System.out.println("结束");
       }
   }
}

第二种方法：代表当前异常不处理这个错误，扔出去，有人调用这个方法，谁调用谁处理。

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;

public class FileTest {
   public static void read() throws Exception{    //代表当前异常不处理这个错误，扔出去，有人调用这个方法，谁调用谁处理。。
       InputStream inputStream=new FileInputStream(new File("hello,world!"));

   }

    public static void main(String[] args) {
        try {
            read();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

或者继续抛出。

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;

public class FileTest {
   public static void read() throws Exception{    //代表当前异常不处理这个错误，扔出去，有人调用这个方法，谁调用谁处理。。
       InputStream inputStream=new FileInputStream(new File("hello,world!"));


   }

    public static void main(String[] args) throws Exception{
        read();
        }
    }

这样一直抛，等于会抛给用户。

尽量能处理的问题不要抛给用户

4.自定义异常

直接继承Exception或者RuntimeException来实现自定义异常。

public class Person {
    String name;
    String gender;
    public  Person(String name,String gender){
        this.name=name;
        this.gender=gender;

    }
}

public class Bathhouse {
    public void  manBathhouse(Person person) throws GenderException{
        if(person.gender.equals("男")){
            System.out.println("欢迎来到男浴室");  //如果是男，欢迎来到男浴室。
        }else {       //否则抛出异常
            throw new GenderException("走错了");
        }
    }
}

//自己定义的必须继承Exception或者RuntimeException
public class GenderException extends Exception {
    public GenderException(String msg){
        super(msg);        //调用父类的构造方法

    }
}

public class GenderTest {
    public static void main(String[] args) throws GenderException{
        Person person1=new Person("张三","男");
        Person person2=new Person("李四","女");

        Bathhouse bathhouse=new Bathhouse();
//        bathhouse. manBathhouse(person1);
        bathhouse.manBathhouse(person2);
    }
}

以上就是我跟这IT老男孩学习的面向对象的笔记，大多是我自己感悟，有的也不一定正确，希望大家批评指正。我觉得经过学习后基本了解了面向对象，以后需要学习的还有很多，数据结构以及数组，对接口，继承，封装，多态的深入了解，以及java的二十三种设计模式，加油吧。

笔记和代码已放到github上面：
笔记：https://github.com/FSDWNS/theory.git
代码：https://github.com/FSDWNS/java.git