zoukankan      html  css  js  c++  java
  • JavaStuNote 4

       装箱(inbox)和拆箱(outbox)

       代表了类类型和基本类型之间的转换行为。

       手动版本号:

       Integer b = new Integer(10);

       Int a = b.intValue;

       自己主动版本号:

       Integer b=30;    à  Integer b=new Integer(30);

       Int a=b;         à  int a =b.intValue();

       由于基本类型和类类型之间的换转操作频繁,SUN公司在高版本号的JDK中提供了自己主动装箱和拆箱操作。由编译器帮助你书写转换代码。

       在JDK5以上版本号才支持自己主动装箱和拆箱操作。

    3. String类了解

        

    String s=new String("abc");

    String m=new String("abc");

    通过new String()语法将告诉编译器创建新对象,所以这里创建两个字符串对象。

        System.out.println(s==m);

    String a="xyz";

    String b="xyz";

    System.out.println(a==b);

    为了兼容C开发人员的习惯,SUN也同意不写new String,而字符串赋值。

        当”xyz”这个字符串对象在内存中不存在的时候,系统将创建一个字符串对象,当已经存在的时候,系统将复用这个对象。

    字符串的不变性(immutable)

    不论什么字符串对象一旦被创建。就不能被更改。通过引用变量导致字符串的改动,都将导致新字符串对象的创建。

    a=a+"mn";

    System.out.println(a==b);

        大量的字符串相加操作会产生大量的字符串对象,比方:

        String a=”superstar”;

        a=a+”m”;

        假设有涉及到较多的字符串相加操作。请使用StringBuffer类。

        

         String s=" this is a book! ";

    System.out.println(s.length()); //求字符串长度

    System.out.println(s.trim().length()); //去除头尾空格

    System.out.println(s.toUpperCase());

    System.out.println("aBcD".toLowerCase());

    System.out.println(s.indexOf('s')); //找出s这个字符在字符串中首次出现的位置

    System.out.println(s.lastIndexOf('s'));//找出s这个字符在字符串中最后一次出现的位置

    System.out.println(s.indexOf("book")); //找出子串出现的位置

    System.out.println(s.indexOf("world!"));

    System.out.println(s.toCharArray()[3]);

    System.out.println(s.charAt(3));

    System.out.println(s.concat("hello,world!")); //字符串相加

    System.out.println("abc".compareTo("bca"));  //-1,0,1

    System.out.println("abc".compareTo("abc"));  //-1,0,1

    System.out.println("cbc".compareTo("bca"));  //-1,0,1

    System.out.println("Abc".compareToIgnoreCase("aBc"));

    System.out.println(s.contains("book"));

    System.out.println(s.endsWith("! "));

    System.out.println(s.isEmpty()); //是否为空

    System.out.println(s.replace('s''m'));

    System.out.println(s.valueOf(1));

    System.out.println(1+"");

    System.out.println("abcdefg".substring(3));

        System.out.println("abcdefg".substring(3,6));

    1.重载 (overload)

       一个类中,可以存在多个同名的方法。在传统的面向过程的编程语言中。方法名不能雷同。那么一个方法名被使用后,将不能在别的地方被利用,有的时候。一个方法名确实非常好用,可以精确表达某个方法的含义。假设不能被重用。就会导致方法名资源的浪费,造成了编程的复杂性。

       方法名同样,參数不同,则构成方法的重载,系统将依据你在方法调用过程中,所传进来的參数的数据类型,选择并运行相应的方法。

       參数不同则构成重载,详细规则例如以下:

       1. 參数数量不同

       2.  相应參数位置的參数数据类型不同

       

       案例:

    int add( int a , int b);      

    int add( int a, int b, int c);

    int add( int a, double c); 

    int add( int a, int d);   

        [參数名不列入重载考虑范围,构成重名]

        void add( int a, int b);

            [返回值不列入重载考虑范围。构成重名]

        

    编译器本质上是不同意方法重名的,这在面向对象编程语言中也是这种, 在程序猿的呼吁中,编译器的开发人员提供了可以名字反复使用的机制。但编译器终于将把方法名做修正,比方:

    int add( int a , int b);         à  add_int_int

    int add( int a, int b, int c);    à  add_int_int_int

    继承环境下,子类即能够重写父类方法。也能够重载父类方法(跨类重载)

    在本类中,仅仅能重载,假设出现类似重写的效果,即推断为错误。认定为重名。

    2. 重写 (override

    在继承环境下,子类认可父类的行为 (认同和坚持方法的签名)。但对行为的详细运行过程不认可,则决定对父亲这种方法进行局部或者全然的更新。

    重写的模式从内容实现上分为2种:

    1) 改良性,补充型重写:对父亲提供的方法内容进行补充。

    2) 颠覆性重写:全然否定父亲所提供的方法内容。彻底改写。

    重写不是覆盖掉父亲的方法。父亲该方法在子类内部还是存在的。在内存中。体现为子类和父类两个同签名方法共存的现象。

    在子类方法中,能够通过super.来显示调用父类被重写的方法,假设不用super. ,则表示调用子类的该重写方法。

        继承环境下子类方法设置的可能情况:

         Class A{

          void sayHello(int a, int b)
    }

    Class B extends A

         Void sayHello(int a, int b){ //在子类中。出现和父类方法同签名,则为重写

          ........

         }

         Void tellYouSomething(int a){ //方法名和全部父类方法均不同,称为子类自己定义新方法

         

         }

         Void sayHello(int a, int b, int c){ //子类对父类方法的签名做部分改造,叫做跨类重载

      

         }

       

        3. 多态 (polymorphism)

        

    a. 多态三要素

    1) 在继承环境下,子类重写父类方法。

    2) 通过父类引用变量指向子类对象。

    3) 恰好通过父类引用变量调用的是被重写的方法。

           

           在此情况下,将发生多态效应。从常态来说,通过父类引用变量指向子类对象,该引用变量仅仅能看到子类对象中的父类部分,不可能调用到子类方法。

    可是因为这里存在重写。通过父类引用变量向子类对象发送信号的时候,该方法调用信号因为和子类重写方法签名是全然一致,结果调用子类的该重写方法,对于方法的主调者来说,其并不知道会产生这个结果。纯属意外。

    b. 多态的用途

    为今后编写框架代码提供了可能,适合用来编写通用底层代码。

        public static void main(String[] args) {

    Mouse mouse=new Mouse();

    Tiger tiger=new Tiger();

    //mouse.sound();

    //tiger.sound();

    //Animal a=new Tiger();

    //a.sound();

    letAnimalSound(new Tiger());

    letAnimalSound(new Mouse());

    letAnimalSound(new Sheep());

       }

        static void letAnimalSound(Animal a){

      a.sound();

    }

    3. 抽象类 (abstract class

        类是模具,有了类,就能够生产对象。

       

    假设一个模具。计划有10个功能,但终于仍然有2个功能没有被实现,这个模具不能用于生产。

      同理,类也有类似的现象,有3个方法,实现了2个, 有1个还没实现,但方法签名已经计划好了这个未实现的方法,必须用abstract来修饰,以通知系统本方法未实现。否则无法通过编译,该方法为抽象方法,拥有一个或者多个抽象方法的类,叫做抽象类。

    抽象类是未完工的类。其不能用于生产实例!

    创建实例       创建子类(继承)     作为引用变量数据类型

    普通类         Yes             Yes                  Yes

    Final类         Yes             No                  Yes

    abstract类       no              Yes                 Yes

    抽象类能够被继承,并且渴望被继承 (愚公移山的故事)

    子类继承父类,实现了父类的全部抽象方法。该子类能够脱掉抽象的帽子。成为普通类。也称可实例化类;否则。假设不实现父类抽象方法,则不管子类自身方法规模多么庞大,也无法忽视内部有一个抽象方法的事实。子类是不完整的,这个不完整是父类带来的,父类是子类的一部分,所以子类也还是抽象类,不能实例化。

    抽象类语法识别注意点:

    a. abstract void method3(){ };  //已经实现了。不能再说是抽象,这是矛盾的。

    b. void method3( ) { };  // 请注意,空实现也是实现。

    以上内容是抽象类的语法解释。以下解说下抽象类的含义:

    1) 被动抽象类

        由于一个类的体内有抽象方法,该类不得不用抽象来修饰。

    2) 主动抽象类

    一个类全部方法都实现了,是可实例化类。其有益主动地声明自己是抽象类。

    一个类的作者为了不让使用者去创建这个类的实例。其有益申明此类为抽象类。

    比方: Animal , Shape, ValueObject…..

    该类作者觉得这个类是一个抽象的概念,没有创建实例的意义。该类须要被继承。然后创建子类实例才有意义。

    不论什么一个类,不管是否有抽象方法,都能够abstract来修饰。

    (例外:

    不能用abstract来修饰已经用final修饰的类

         Abstract类渴望被继承,而final拒绝继承。两者构成反义关系。不能同一时候存在,否则就构成了矛盾。

    5. 訪问修饰符 (access modifier)

       现实生活中。一个人有非常多属性, 其不会把全部的属性都告诉不论什么人,而是有选择性对外说明,起到一个自我保护的作用,这也是算是一种“封装 encapsulation”。

       依据软件模拟现实的原则,语言设计者推出了訪问修饰符这个机制来实现封装。

       

    a. 从继承角度谈訪问修饰符

                           本类          同包子类         异包子类

    Private                 yes            no             no

    <package>              yes            yes             no

    Protected               yes            yes             yes

    Public                  yes            yes             yes

    Protected

    能够被继承的意思

    <package>修饰符仅仅有本包内部类可见,外部类。即使是子类也看不到。

    Protected 修饰符不仅本包内部可见。外包子类也可见。

    b. 从引用角度谈訪问修饰符

                   本类   同包子类   同包非子类  异包子类   异包非子类

    Private        yes     no          no         no        no

    <package>    yes     yes          yes        no        no

    Protected      yes     yes          yes        no        no

    Public         yes      yes          yes        yes       yes

     





  • 相关阅读:
    Autofac 学习简易教程随笔(一)
    实现Entity Framework SQLite Code First 开发
    Entity Framework SQLite 开发及实现简单的自定义Migration Engine
    MSSQLServer和SQL Server Express、LocalDB的区别
    .gitignore文件
    Entity Framework MSSQL Code First 开发
    页面为要加<!DOCTYPE html>
    数字图像处理(下)
    数字图像处理(上)
    列表
  • 原文地址:https://www.cnblogs.com/llguanli/p/7281389.html
Copyright © 2011-2022 走看看