用户登入注册

2019-05-20 09:55 来源:未知

API:

今日内容介绍
1、Object
2、String
3、StringBuilder

(1)equals方法比较内存地址

Java API就是JDK中提供给我们使用的类,这些类将底层的代码实现封装了起来,我们不需要关心这些类是如何实现的,只需要学习这些类如何使用即可。

01API概念

  • A:API(Application Programming Interface)
    • 应用程序编程接口
  • B:Java API
    • 就是Java提供给我们使用的类,这些类将底层的实现封装了起来,
    • 我们不需要关心这些类是如何实现的,只需要学习这些类如何使用。
  • C: 演示查看Object类中的相关方法

        * a: Object类中的equals方法

源文件使用方法:

02Object类概述

  • A:Object类概述
    • 类层次结构的根类
    • 所有类都直接或者间接的继承自该类
    • Object中描述的所有方法子类都可以使用
    • 所有类在创建对象的时候,最终找的父类就是Object。
  • B:构造方法
    • public Object()
    • 回想面向对象中为什么说:
      • 子类的构造方法默认访问的是父类的无参构造方法

* 用于比较两个对象是否相同,Object类中就是使用两个对象的内存地址在比较。  * Object类中的equals方法内部使用的就是==比较运算符。

图片 1

03equals方法比较内存地址

图片 2

  • A:equals方法比较内存地址

    • a: Object类中的equals方法
      • 用于比较两个对象是否相同,Object类中就是使用两个对象的内存地址在比较。
      • Object类中的equals方法内部使用的就是==比较运算符。
    • b: 案例代码

        public class Person extends Object{
            private String name;
            private int age;
      
            public Person(){}
      
            public Person(String name, int age) {
                this.name = name;
                this.age = age;
            }
            /*
             * 将父类的equals方法写过来,重写父类的方法
             * 但是,不改变父类方法的源代码, 方法equals 比较两个对象的内存地址
             *              
             */
            public boolean equals(Object obj){                  
                return this == obj;
            }       
      
            public String getName() {
                return name;
            }
            public void setName(String name) {
                this.name = name;
            }
            public int getAge() {
                return age;
            }
            public void setAge(int age) {
                this.age = age;
            }                
        }
        //测试代码
        public class TestEquals {
            public static void main(String[] args) {
                //Person类继承Object类,继承下来了父类的方法equals
                Person p1 = new Person("李四",20);
                Person p2 = new Person("张三",20);
      
                  //Person对象p1,调用父类的方法equals,进行对象的比较
                  boolean b = p1.equals(p1);
                  System.out.println(b);

              }
          }

(2): 重写equals方法

 

04重写equals方法

  • A: 重写equals方法

    • a: 开发中要比较两个对象是否相同,经常会根据对象中的属性值进行比较
    • b: 在开发经常需要子类重写equals方法根据对象的属性值进行比较。
    • c: ==号和equals方法的区别
      • ==是一个比较运算符号,既可以比较基本数据类型,也可以比较引用数据类型,基本数据类型比较的是值,引用数据类型比较的是地址值
      • equals方法是一个方法,只能比较引用数据类型,所有的对象都会继承Object类中的方法,如果没有重写Object类中的equals方法,
        equals方法和==号比较引用数据类型无区别,重写后的equals方法比较的是对象中的属性
    • d: 案例代码
    • public class Person extends Object{

          private String name;
          private int age;
      
          public Person(){}
      
          public Person(String name, int age) {
              this.name = name;
              this.age = age;
          }
          /*
           * 重写父类的方法toString()
           * 没有必要让调用者看到内存地址
           * 要求: 方法中,返回类中所有成员变量的值
           */
          public String toString(){
              return name   age;
          }
      
              /*
               * 将父类的equals方法写过来,重写父类的方法
               * 但是,不改变父类方法的源代码, 方法equals 比较两个对象的内存地址
               * 
               * 两个对象,比较地址,没有意义
               * 比较两个对象的成员变量,age
               * 两个对象变量age相同,返回true,不同返回false
               * 
               * 重写父类的equals,自己定义自己对象的比较方式
               */
              public boolean equals(Object obj){
                  if( this == obj){
                      return true;
                  }

                  //对参数obj,非null判断
                  if( obj == null){
                      return false;
                  }

                  if( obj instanceof Person){
                      // 参数obj接受到是Person对象,才能转型
                      // 对obj参数进行类型的向下转型,obj转成Person类型
                      Person p = (Person)obj;
                      return this.age ==  p.age;
                  }
                  return false;
              }               

              public String getName() {
                  return name;
              }
              public void setName(String name) {
                  this.name = name;
              }
              public int getAge() {
                  return age;
              }
              public void setAge(int age) {
                  this.age = age;
              }                
          }
          //测试代码
          public class TestEquals {
              public static void main(String[] args) {
                  //Person类继承Object类,继承下来了父类的方法equals
                  Person p1 = new Person("李四",20);
                  Person p2 = new Person("张三",20);


                  //Person对象p1,调用父类的方法equals,进行对象的比较
                  boolean b = p1.equals(p1);
                  System.out.println(b);

              }
          }           

  * a: 开发中要比较两个对象是否相同,经常会根据对象中的属性值进行比较              * b: 在开发经常需要子类重写equals方法根据对象的属性值进行比较。                    * c: ==号和equals方法的区别                   * ==是一个比较运算符号,既可以比较基本数据类型,也可以比较引用数据类型,基本数据类型比较的是值,引用数据类型比较的是地址值  * equals方法是一个方法,只能比较引用数据类型,所有的对象都会继承Object类中的方法,如果没有重写Object类中的equals方法, equals方法和==号比较引用数据类型无区别,重写后的equals方法比较的是对象中的属性

 

05重写toString方法

  • A: 重写toString方法

    • a: 为什么要重写toString方法
      • toString方法返回该对象的字符串表示,其实该字符串内容就是对象的类型 @ 内存地址值。
      • 由于toString方法返回的结果是内存地址,而在开发中,经常需要按照对象的属性得到相应的字符串表现形式,因此也需要重写它。
      • Object类中的toString的核心代码
        getClass().getName() "@" Integer.toHexString(hashCode())
      • 由于默认情况下的数据对我们来说没有意义,一般建议重写该方法。
    • b: 案例核心代码(重写Person类中的toString方法)
    • /*

       * 重写父类的方法toString()
       * 没有必要让调用者看到内存地址
       * 要求: 方法中,返回类中所有成员变量的值
       */
      public String toString(){
          return name   age;
      }   
      //Eclipse中自动生成的toString
      @Override
      public String toString() {
          return "Person [name="   name   ", age="   age   "]";
      }
      //测试代码
      public class TestToString {
          public static void main(String[] args) {
              //调用Person类的方法toString()
              //输出语句中,写的是一个对象,默认调用对象的toString方法
              Person p = new Person("张三",20);
              String s = p.toString();
              System.out.println(p);
              System.out.println(s);
              /*
               * System.out.println(p);
               * System.out.println(p.toString());
               */
      
              /*Random r = new Random();
              System.out.println(r.toString());
      
              Scanner sc = new Scanner(System.in);
              System.out.println(sc.toString());*/
          }
      }
      

(3) 重写toString方法

 

06String类的概念和不变性

  • A: String类的概念和不变性
    • a:String类
      • API中的String类的描述,发现String 类代表字符串
      • Java 程序中的所有字符串字面值(如 "abc" )都作为此类的实例实现。
      • 字符串是常量,在创建之后不能更改
      • 其实就是说一旦这个字符串确定了,那么就会在内存区域中就生成了这个字符串。字符串本身不能改变,但str变量中记录的地址值是可以改变的。
      • 源码分析,String类底层采用的是字符数组:
        private final char value[]
        private 修饰说明value只能在String类内部使用,而且又没有提供get方法,所以外部无法获取value数组,就无法改变数组中元素的值
        final修饰说明value是常量,一旦创建,就不能被改变,value一旦被初始化成某个数组,将永远指向这个数组,不可能再指向其它的数组了
    • b: 案例代码
    • /*
       *   String类特点:
       *     一切都是对象,字符串事物 "" 也是对象
       *     类是描述事物,String类,描述字符串对象的类
       *     所有的 "" 都是String类的对象
       *     
       *     字符串是一个常量,一旦创建,不能改变
       */
      public class StringDemo {
          public static void main(String[] args) {
              //引用变量str执行内存变化
              //定义好的字符串对象,不变
              String str = "itcast";
              System.out.println(str);
              str = "itheima";
              System.out.println(str);
      
              }
          }

        * a: 为什么要重写toString方法 * toString方法返回该对象的字符串表示,其实该字符串内容就是对象的类型 @ 内存地址值。                                                             * 由于toString方法返回的结果是内存地址,而在开发中,经常需要按照对象的属性得到相应的字符串表现形式,因此也需要重写它。                                                     * Object类中的toString的核心代码       getClass().getName() "@" Integer.toHexString(hashCode())                                      * 由于默认情况下的数据对我们来说没有意义,一般建议重写该方法。

Object类概述:

07String类创建方式和比较

  • A: String类创建方式和比较

    • a: 创建对象的数量比较
      • String s3 = "abc";
        • 在内存中只有一个对象。这个对象在字符串常量池中
      • String s4 = new String("abc");
        • 在内存中有两个对象。一个new的对象在堆中,一个字符串本身对象,在字符串常量池中
    • b: 案例代码
    • public class StringDemo2 {

          public static void main(String[] args) {
              //字符串定义方式2个, 直接=  使用String类的构造方法
              String str1 = new String("abc");
              String str2 = "abc";
              System.out.println(str1);
              System.out.println(str2);
      
              System.out.println(str1==str2);//引用数据类型,比较对象的地址 false
              System.out.println(str1.equals(str2));//true
          }
      }
      

(4) String类的概念和不变性                     * a:String类                                                  * API中的String类的描述,发现String 类代1表字符串                                             * Java 程序中的所有字符串字面值(如 "abc" )都作为此类的实例实现。     * 字符串是常量,在创建之后不能更改       * 其实就是说一旦这个字符串确定了,那么就会在内存区域中就生成了这个字符串。字符串本身不能改变,但str变量中记录的地址值是可以改变的。                                        * 源码分析,String类底层采用的是字符数组:

Object类是类层次的根类,即所有类的父类。它中描述的所有方法子类都可以使用。所有类在创建对象的时候,最终找的父类就是Object。

08String类构造方法

  • A: String类构造方法

    • a: 常见构造方法
      • public String():空构造
        • public String(byte[] bytes):把字节数组转成字符串
        • public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串
        • public String(String original):把字符串常量值转成字符串
    • b: 案例代码

    • public class StringDemo3 {

          public static void main(String[] args) {
              function_1();
          }
          /*
           *  定义方法,String类的构造方法
           *  String(byte[] bytes)  传递字节数组
           *  字节数组转成字符串
           *  通过使用平台的默认字符集解码指定的 byte 数组,构造一个新的 String。
           *  平台 : 机器操作系统
           *  默认字符集: 操作系统中的默认编码表, 默认编码表GBK
           *  将字节数组中的每个字节,查询了编码表,得到的结果
           *  字节是负数,汉字的字节编码就是负数, 默认编码表 ,一个汉字采用2个字节表示
           *  
           *  String(byte[] bytes, int offset, int length) 传递字节数组
           *  字节数组的一部分转成字符串
           *  offset 数组的起始的索引
           *  length 个数,转几个   , 不是结束的索引
           */
          public static void function(){
              byte[] bytes = {97,98,99,100};
              //调用String类的构造方法,传递字节数组
              String s = new String(bytes);
              System.out.println(s);
      
              byte[] bytes1 ={65,66,67,68,69};
              //调用String构造方法,传递数组,传递2个int值
              String s1 = new String(bytes1,1,3);
              System.out.println(s1);
          }
      }
      

                private final char value[]

Object类:构造方法中的super()调用Object()空参构造

09String类构造方法_2

  • A: String类构造方法

    • a: 常见构造方法

      • public String(char[] value):把字符数组转成字符串
      • public String(char[] value,int index,int count):把字符数组的一部分转成字符串
  • B: 案例代码

  • /*

     *  String类构造方法
     *  String类的构造方法,重载形式
     * 
     */
    

    public class StringDemo3 {

       public static void main(String[] args) {
           function_1();
       }
       /*
        * String(char[] value) 传递字符数组
        * 将字符数组,转成字符串, 字符数组的参数,不查询编码表
        * 
        * String(char[] value, int offset, int count) 传递字符数组
        * 将字符数组的一部分转成字符串
        * offset  数组开始索引
        * count   个数
        */
       public static void function_1(){
           char[] ch = {'a','b','c','d','e','f'};
           //调用String构造方法,传递字符数组
           String s = new String(ch);
           System.out.println(s);
    
           String s1 = new String(ch,1,4);
           System.out.println(s1);
       }
    

    }

                private 修饰说明value只能在String类内部使用,而且又没有提供get方法,所以外部无法获取value数组,就无法改变数组中元素的值

 

10String类的其他方法

* A:String类的其他方法
    * a: 方法介绍
        * int length(): 返回字符串的长度
        * String substring(int beginIndex,int endIndex): 获取字符串的一部分
        * String substring(int beginIndex): 获取字符串的一部分
        * boolean startsWith(String prefix): 判断一个字符串是不是另一个字符串的前缀,开头
        * boolean endsWith(String prefix): 判断一个字符串是不是另一个字符串的后缀,结尾
        * boolean contains (String s): 判断一个字符串中,是否包含另一个字符串
        * int indexOf(char ch):  查找一个字符,在字符串中第一次出现的索引,被查找的字符不存在,返回-1
        * byte[] getBytes(): 将字符串转成字节数组,此功能和String构造方法相反,byte数组相关的功能,查询编码表
        * char[] toCharArray(): 将字符串转成字符数组,功能和构造方法相反
        * boolean equals(Object obj): 方法传递字符串,判断字符串中的字符是否完全相同,如果完全相同返回true
        * boolean equalsIgnoreCase(String s): 传递字符串,判断字符串中的字符是否相同,忽略大小写         

    * b: 案例代码

        public class StringDemo4 {
            public static void main(String[] args) {
                function_9();
            }
            /*
             *  boolean equals(Object obj)
             *  方法传递字符串,判断字符串中的字符是否完全相同,如果完全相同返回true
             *  
             *  boolean equalsIgnoreCase(String s)
             *  传递字符串,判断字符串中的字符是否相同,忽略大小写
             */
            public static void function_9(){
                String str1 = "Abc";
                String str2 = "abc";
                //分别调用equals和equalsIgnoreCase
                boolean b1 = str1.equals(str2);
                boolean b2 = str1.equalsIgnoreCase(str2);
                System.out.println(b1);
                System.out.println(b2);
            }

            /*
             * char[] toCharArray() 将字符串转成字符数组
             * 功能和构造方法相反
             */
            public static void function_8(){
                String str = "itcast";
                //调用String类的方法toCharArray()
                char[] ch = str.toCharArray();
                for(int i = 0 ; i < ch.length ; i  ){
                    System.out.println(ch[i]);
                }
            }

            /*
             *  byte[] getBytes() 将字符串转成字节数组
             *  此功能和String构造方法相反
             *  byte数组相关的功能,查询编码表
             */
            public static void function_7(){
                String str = "abc";
                //调用String类方法getBytes字符串转成字节数组
                byte[] bytes = str.getBytes();
                for(int i = 0 ; i < bytes.length ; i  ){
                    System.out.println(bytes[i]);
                }
            }

            /*
             *  int indexOf(char ch)
             *  查找一个字符,在字符串中第一次出现的索引
             *  被查找的字符不存在,返回-1
             */
            public static void function_6(){
                String str = "itcast.cn";
                //调用String类的方法indexOf
                int index = str.indexOf('x');
                System.out.println(index);
            }

            /*
             *  boolean contains (String s)
             *  判断一个字符串中,是否包含另一个字符串
             */
            public static void function_5(){
                String str = "itcast.cn";
                //调用String类的方法contains
                boolean b =str.contains("ac");
                System.out.println(b);
            }

            /*
             * boolean endsWith(String prefix)
             * 判断一个字符串是不是另一个字符串的后缀,结尾
             * Demo.java
             *     .java
             */
            public static void function_4(){
                String str = "Demo.java";
                //调用String类方法endsWith
                boolean b = str.endsWith(".java");
                System.out.println(b);
            }

            /*
             * boolean startsWith(String prefix)  
             * 判断一个字符串是不是另一个字符串的前缀,开头
             * howareyou
             * hOw
             */
              public static void function_3(){
                  String str = "howareyou";
                  //调用String类的方法startsWith
                  boolean b = str.startsWith("hOw");
                  System.out.println(b);
              }

            /*
             *  String substring(int beginIndex,int endIndex) 获取字符串的一部分
             *  返回新的字符串
             *  包含头,不包含尾巴
             *  
             *  String substring(int beginIndex)获取字符串的一部分
             *  包含头,后面的字符全要
             */
            public static void function_2(){
                String str = "howareyou";
                //调用String类方法substring获取字符串一部分
                str= str.substring(1, 5);
                System.out.println(str);

                String str2 = "HelloWorld";
                str2 = str2.substring(1);
                System.out.println(str2);
            }

            /*
             *  int length() 返回字符串的长度
             *  包含多少个字符
             */
            public static void function(){
                String str = "cfxdf#$REFewfrt54GT";
                //调用String类方法length,获取字符串长度
                int length = str.length();
                System.out.println(length);
            }
        }

                final修饰说明value是常量,一旦创建,就不能被改变,value一旦被初始化成某个数组,将永远指向这个数组,不可能再指向其它的数组了

 

11String类练习

  • A: 获取指定字符串中,大写字母、小写字母、数字的个数

    • a: 题目分析
      • 为了统计大写字母、小写字母、数字的个数。创建3个计数的变量。
      • 为了获取到字符串中的每个字符,进行字符串的遍历,得到每个字符。
      • 对得到的字符进行判断,如果该字符为大写字母,则大写字母个数 1;如果该字符为小写字母,则小写字母个数 1;如果该字符为数字,则数字个数 1。
      • 显示大写字母、小写字母、数字的个数
    • b: 解题步骤
    • 案例代码

        public class StringTest {
            public static void main(String[] args) {
                getCount("A 
版权声明:本文由韦德娱乐1946_韦德娱乐1946网页版|韦德国际1946官网发布于网络编程,转载请注明出处:用户登入注册