我在乐字节学习的第十二天（Java）

今天是我在乐字节学习Java的第十二天哟，Java学习起来很有趣哦，通过学习Java可以提高自己的逻辑思维能力，老师讲课的内容也很多，当然收获也是满满滴哦~编程时一项很严谨的工作：一定要细心，一点点的不i严谨，可能dao会导致整个项目出问题，正所谓：差之毫厘，失之千里；

第一章 多态

1.1 多态的概述

注意：1.继承性指的是以下三种： 类与类之间的继承extends，类与接口之间的实现implements，接口与接口之间的extends2.多态性： 多态性是指对象的多态性，注意是针对对象而言的。

1.2 多态的格式与使用

代码当中体现多态性，其实就是一句话，父类指向子类引用对象格式：

父类名称 对象名 = new 子类名称();

1

或者

接口名称 对象名 = new 实现类名称();

1

1.2.1 多态中成员变量的使用特点（和继承当中完全一样）

两种情况：1.当采用对象直接访问成员变量时，看创建对象时，等式左边是谁，就优先用谁

//  定义父类

public class Fu {

   int  num = 10;

}

​

//  定义子类

public class Zi extends Fu{

   int num = 20;

}

​

//  定义测试类

public class Demo01MultiField {

   public static void main(String[] args) {

       //  使用多态的写法，父类引用指向子类对象

       Fu obj = new Zi();

       System.out.println(obj.num);    //  父：10

}

1234567891011121314151617

2.间接通过成员方法访问成员变量：看该方法属于谁，就优先用谁当中的变量，没有则向上查找

//  定义父类

public class Fu {

   int  num = 10;

​

   //  这个方法是父类的，所以优先使用父类里的num，不会向下查找

   public void showNum(){

       System.out.println(num);

   }

​

//  定义子类

public class Zi extends Fu{

   int num = 20;

   int age = 16;

​

   @Override

   //  这个方法是子类的，所以优先使用子类里的num，如果子类没有再向上查找父类当中有无num

   public void showNum(){

       System.out.println(num);

   }

​

//  定义测试类

public class Demo01MultiField {

   public static void main(String[] args) {

       //  使用多态的写法，父类引用指向子类对象

       Fu obj = new Zi();

       System.out.println(obj.num);    //  父：10

//        System.out.println(obj.age);  //  错误写法，通过对象名访问成员变量是看等号左边的，在这种多态方式下也就是看父类，而不会向下查看子类

       System.out.println("=====================");

​

       //  子类没有覆盖重写，就是父：10

       //  子类如果覆盖重写，就是子：20

       obj.showNum();

   }

}

12345678910111213141516171819202122232425262728293031323334

总结： 编译看左，运行还看左。 因此，若父类当中没有相应的变量，则程序会编译不通过，也就是无法访问子类特有的属性。

1.2.2 多态中成员方法的使用特点

规则： 看创建对象时候new的是谁，就优先用谁记忆口诀： 编译看左，运行看右口诀理解： 在使用多态方式调用方法时，首先查看父类当中有无相应的方法，若有，则执行子类当中进行重写或继承下来的相应方法。若父类当中无相应的方法，则编译报错。 所以，多态创建的对象，无法访问子类特有的方法

//  定义父类

public class Fu {

   int  num = 10;

​

   //  这个方法是父类的，所以优先使用父类里的num，不会向下查找

   public void showNum(){

       System.out.println(num);

   }

​

   public void method(){

       System.out.println("父类方法");

   }

​

   public void methodFu(){

       System.out.println("父类特有方法");

   }

}

​

//  定义子类

public class Zi extends Fu{

   int num = 20;

   int age = 16;

​

   @Override

   //  这个方法是子类的，所以优先使用子类里的num，如果子类没有再向上查找父类当中有无num

   public void showNum(){

       System.out.println(num);

   }

​

   @Override

   public void method(){

       System.out.println("子类方法");

   }

​

​

   public void methodZi(){

       System.out.println("子类特有方法");

   }

}

​

//  定义测试类

public class Demo02MultiMethod {

   public static void main(String[] args) {

       Fu obj = new Zi();  //  多态

​

       obj.method();   //  父子都有，new的是子所以优先用子

       obj.methodFu(); //  子类没有，父类有，向上查找到父类（也可以理解为从父类当中继承下来）

​

       //  编译看左边，左边是Fu，Fu当中没有methodZi方法，所以编译报错。

//        obj.methodZi();  // 错误写法

   }

}

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152

1.3 使用多态的好处和弊端

好处：弊端：多态创建的对象无法使用子类特有的内如（属性，方法）

1.4 对象的向上转型

多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。

对比数据类型的转换,就好像是：double a = 10;左边定义的是double类型的变量a，但右边赋值的是一个int类型的10，这时会发生数据的类型转换，由于是从小范围到大范围所以一定是安全的，是默认的。

注意：Java在创建对象时候也是可以像创建数组、基本数据类型变量一样采用两步走的方式。，也就是先声明，再创建（1）对象的声明：类名 对象名（2）对象的创建：对象名 =new 类名（）

当父类引用指向一个子类对象时，便是向上转型。

// 定义父类Animal

public abstract class Animal {

   public abstract void eat();

}

​

//  定义子类Cat

public class Cat extends Animal{

   @Override

   public void eat(){

       System.out.println("猫吃鱼");

   }

​

   //  子类特有方法

   public void catchMouse(){

       System.out.println("猫抓老鼠");

   }

}

​

//  定义测试类

public class Demo01Main {

   public static void main(String[] args) {

       //  对象的向上转型，就是父类引用指向子类对象

       Animal animal = new Cat();  //  本来创建的时候是一只猫

animal.eat();  //  猫吃鱼

​

//        animal.catchMouse;  //  按照访问成员方法的规则来看，编译看左则编译不会进行通过，因此是错误写法！

}

123456789101112131415161718192021222324252627

向上转型的弊端： 对象一旦向上转型为父类，那么就无法调用子类原本特有的内容

解决方案： 将已经进行向上转型的对象再次转换为原本的子类对象，也即是 【向下转型】

1.5 对象的向下转型

概念： 父类类型向子类类型向下转换的过程，这个过程是强制的。转换格式：

子类名称 变量名 = （子类名称） 父类变量名；

1

//  定义父类Animal

public abstract class Animal {

   public abstract void eat();

}

​

//  定义子类Cat

public class Cat extends Animal{

   @Override

   public void eat(){

       System.out.println("猫吃鱼");

   }

​

   //  子类特有方法

   public void catchMouse(){

       System.out.println("猫抓老鼠");

   }

}

​

//  定义子类Dog

public class Dog extends Animal{

   @Override

   public void eat(){

       System.out.println("狗吃肉");

   }

​

   public void watchHouse(){

       System.out.println("狗看家");

   }

}

​

//  定义测试类

public class Demo01Main {

   public static void main(String[] args) {

       //  对象的向上转型，就是父类引用指向子类对象

       Animal animal = new Cat();  //  本来创建的时候是一只猫

       animal.eat();

​

//        animal.catchMouse;  //  错误写法！

​

       //  向下转型，进行“还原”动作

       Cat cat = (Cat) animal;

       cat.catchMouse();   //  猫抓老鼠

​

       //  下面是错误的向下转型

       //  本来new的时候是一只猫，现在非要当做狗

       //  错误写法！编译不会报错，但是运行会产生异常

       //  java.lang.ClassCastException,类转换异常

//        Dog dog = (Dog) animal;

​

   }

}

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051

注意： 上面所说的向上转型，向下转型等规则，不仅适用于父类和子类的转换，也适用于接口和实现类之间的转换。

1.6 instanceof关键字

在进行向下转型的时候，很有可能忘记转型错误而发生ClassCastException。如以下代码：

//  定义父类

public class abstract Animal{

    public abstract void eat();

}

​

//  定义子类Cat

public class Cat extends Animal{

    @Override

    public void eat(){

        System.out.println("猫吃鱼);

    }

    public void catchMouse(){

        System.out.println("猫抓老鼠");

    }

}

​

//  定义子类Dog

public class Dog extends Animal{

    @Override

    public void eat(){

        System.out.println("狗吃肉");

    }

​

    public void watchHouse(){

        System.out.println("狗看家");

    }

}

​

//  定义测试类

public class Demo01{

    public static void main(String[] args){

        //  使用多态创建一个对象

        Animal animal = new Cat();

        animal.eat();  //  猫吃鱼

        animal.catchMouse();    //  猫抓老鼠

​

        //  向下转型

//      Dog d = (Dog) animal;  //  转型的不是原本的Cat，而是Dog

//      d.eat();

//      d.watchHouse(); //  调用的是Dog的方法watchHouse


    }

}

12345678910111213141516171819202122232425262728293031323334353637383940414243

上面的代码在进行编译的时候是不会报错的，但是在运行的时候会报出ClassCastException错误，也即是类型转换异常！ 这是因为，明明创建了Cat类型对象，运行时，当然不能转换成Dog对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。

为此，Java提供了instanceof关键字来进行检验一个对象能否看做某一个类型，从而来进行正确的向下转型。instanceof关键字使用格式如下：

变量名 instanceof  数据类型

如果变量属于该数据类型，返回true。

如果变量不属于该数据类型，返回false。

123

对刚才的代码块进行修正如下：

//  定义父类

public class abstract Animal{

    public abstract void eat();

}

​

//  定义子类Cat

public class Cat extends Animal{

    @Override

    public void eat(){

        System.out.println("猫吃鱼);

    }

    public void catchMouse(){

        System.out.println("猫抓老鼠");

    }

}

​

//  定义子类Dog

public class Dog extends Animal{

    @Override

    public void eat(){

        System.out.println("狗吃肉");

    }

​

    public void watchHouse(){

        System.out.println("狗看家");

    }

}

​

//  定义测试类

public class Demo01{

    public static void main(String[] args){

        //  使用多态创建一个对象

        Animal animal = new Cat();

        animal.eat();  //  猫吃鱼

​

        //  向下转型

        if(animal instanceof Cat){

            Cat cat = (Cat) animal;

            cat.catchMouse();

        }else if(animal instanceof Dog){

            Dog dog = (Dog) animal;

            dog.watchHouse();

        }

    }

}

123456789101112131415161718192021222324252627282930313233343536373839404142434445

第二章 final关键字

2.1 概述

final关键字代表最终的，不可改变的。

不可变： 对于基本数据类型来说，不可变是指变量当中的数据不可变。对于引用数据类型来说，不可变说的是变量当中的地址值不可改变

final关键字有四种常见用法：

用来修饰一个类

用来修饰一个方法

用来修饰一个局部变量

用来修饰一个成员变量

2.2 final关键字用来修饰一个类

格式：

public final class 类名称{

    ...

}

123

当一个类用final关键字进行修饰时，意味着这个类不能有任何的子类，同时也意味着这个类里的所有方法都无法进行重写。（太监类）但是，这个类可以有父类。

2.2 final关键字用来修饰一个方法

当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。因此，不难理解。对于类和方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。

格式：

修饰符 final 返回值类型 方法名称(参数列表){

   //  方法体

}

123

2.3 final关键字来修饰一个局部变量

一旦使用final用来修饰局部变量（可以是基本/引用数据类型），那么这个局部变量将只能赋值一次，且不能进行更改。类似于字符串.当局部变量是基本数据类型时，就是其中的数据不能改变。当局部变量是引用数据类型时，就是其变量的地址值不能改变

代码演示如下：

//  定义Student类

public class Student {

   private String name;

​

   public Student() {

   }

​

   public Student(String name) {

       this.name = name;

   }

​

   public String getName() {

       return name;

   }

​

   public void setName(String name) {

       this.name = name;

   }

}

​

//  定义测试类

public class Demo01Final {

   public static void main(String[] args) {

       int num1 = 10;

       System.out.println(num1);   //  10

       num1 = 20;

       System.out.println(num1);   //  20

​

       //  一旦使用final用来修饰“局部”变量（基本数据类型），那么这个局部变量将只能赋值一次，且不能进行更改。类似于字符串

       //  “一次赋值，终生不变”

       final int num2 = 200;

       System.out.println(num2);   //  200

​

//        num2 = 500;   //  错误写法！不能改变！

//        num2 = 200;   //  错误写法!

​

       //  正确写法,只要保证有唯一一次的赋值即可

       final int num3;

       num3 = 30;

​

       //  对于基本类型来说，不可变说的是变量当中的数据不可改变

       //  对于引用数据类型来说，不可变说的是变量当中的地址值不可改变

       Student stu1 = new Student("泰隆");

       System.out.println(stu1);   //  输出地址值

       System.out.println(stu1.getName()); //  泰隆


        //  stu1是一个Student类型的变量

       //  根据上面代码可知其当前保存的是一个Student对象的内存地址

       //  而下面这行代码意思是，等号右边是创建了一个新的Student对象

       //  结合起来看就是把这个new出来的对象的内存地址值交给这个Student类型的stu1变量

//  下面这行代码可以理解为Student stu1和stu1 = new Student("艾瑞莉娅"); 这两行代码分开创建了一个对象

//  有点像数组的两步走创建

       stu1 = new Student("艾瑞莉娅");

       System.out.println(stu1);   //  输出地址值

       System.out.println(stu1.getName());

       System.out.println("==============================");

​

        //  final用来修饰局部变量（引用数据类型）

       final Student stu2 = new Student("卡特琳娜");

//        stu2 = new Student("卡兹克");  //  错误写法，final的引用类型变量，其中的地址值不可改变

       System.out.println(stu2.getName()); //  卡特琳娜

       stu2.setName("卡特琳娜娜娜娜娜");

       System.out.println(stu2.getName()); //  卡特琳娜娜娜娜娜

​

   }

}

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566

2.4 final关键字用来修饰一个成员变量【重点】

对于成员变量来说，如果使用final关键字，那么这个变量照样也是不可变注意事项：1.由于成员变量有默认值，所以用了final以后必须手动赋值，不会再给默认值了。2.对于final的成员变量，要么通过直接赋值，要么通过“构造方法”赋值。二者选其一。3.必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值。

©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 204,921评论 6赞 478
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 87,635评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 151,393评论 0赞 338
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,836评论 1赞 277
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,833评论 5赞 368
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,685评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,043评论 3赞 399
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,694评论 0赞 258
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 42,671评论 1赞 300
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,670评论 2赞 321
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,779评论 1赞 332
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,424评论 4赞 321
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,027评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,984评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,214评论 1赞 260
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,108评论 2赞 351
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,517评论 2赞 343

推荐阅读更多精彩内容