后端入门—面向对象基本理解(第二部分)

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

【信息由网络或者个人提供,如有涉及版权请联系COOY资源网邮箱处理】

© 版权声明
THE END
喜欢就支持一下吧
点赞11 分享
评论 抢沙发

请登录后发表评论

    暂无评论内容