java 10.28/29

一  Object类（类层次结构的根类）

    每个类都使用 Object 作为超类(父类)     所有对象（包括数组）都实现这个类的方法。

    方法：

     1. public int hashCode()返回该对象的哈希码值

     2.Class类中有一个方法:
        public String getName()以 String 的形式返回此 Class 对象所表示的实体（类、接口、数组类、基本类型或 void）名称

     3.public String toString();  返回该对象的字符串表示(建议所有子类都重写此方法)

                    如果直接输出对象名称,想要显示当前对象的成员变量的值,那么必须重写Object类中的toString()方法  alt +shift +s +s

     4.public boolean equals(Object obj)   指示其他某个对象是否与此对象“相等”

               ==:比较的是两个对象的地址值是否相同          如果重写了Object类中的equals()方法,那么默认比较就是两个对象的内容是否相同

     5.protected void finalize()throws Throwable: 当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法

              System类中的一个方法:
               public void gc():运行垃圾回收器,这个垃圾回收器最终调用的就是finalize()方法

     6.protected Object clone()创建并返回此对象的一个副本.

       Object 类的 clone 方法执行特定的复制操作。首先，如果此对象的类不能实现接口 Cloneable，则会抛出  编译时期异常CloneNotSupportedException

示例代码1

        

 package org.lemon.Object类;

public class ObjectDemo1 {
  public static void main(String[] args) {
 Student s1 = new Student ("我爱你",20);
 Student s2 = new Student ("我爱你",20);
 System.out.println(s1.equals(s2));
}
}

package org.lemon.Object类;

public class Student {
  private String name;
  private int age;
public Student() {
 super();
 
}
public Student(String name, int age) {
 super();
 this.name = name;
 this.age = age;
}
/**
 * @return the name
 */
public String getName() {
 return name;
}
/**
 * @param name the name to set
 */
public void setName(String name) {
 this.name = name;
}
/**
 * @return the age
 */
public int getAge() {
 return age;
}
/**
 * @param age the age to set
 */
public void setAge(int age) {
 this.age = age;
}
/* (non-Javadoc)
 * @see java.lang.Object#hashCode()
 */

@Override
public boolean equals(Object obj) {
 if (this == obj)
  return true;
 if (obj == null)
  return false;
 if (getClass() != obj.getClass())
  return false;
 Student other = (Student) obj;
 if (age != other.age)
  return false;
 if (name == null) {
  if (other.name != null)
   return false;
 } else if (!name.equals(other.name))
  return false;
 return true;
}
  }

示例代码2

   

package org.lemon.Object类2;

public class ObjectDemo2 {
  public static void main(String[] args) throws CloneNotSupportedException {
 //创建 Srudent 类
   Student s = new Student();
   s.setName("海沃德");
   s.setAge(28);
   System.out.println(s.getName()+"---"+s.getAge());
  
  
   //复制s  对象
   Object obj = s.clone();
   //向下转型
   Student s1 = (Student) obj;
   System.out.println(s1.getName()+"---"+s1.getAge());
}
}

package org.lemon.Object类2;
// 实现 Cloneable 接口
public class Student implements Cloneable {
 private String name ;
 private int age ;
public Student() {
 super();
 // TODO Auto-generated constructor stub
}
public Student(String name, int age) {
 super();
 this.name = name;
 this.age = age;
}
/**
 * @return the name
 */
public String getName() {
 return name;
}
/**
 * @param name the name to set
 */
public void setName(String name) {
 this.name = name;
}
/**
 * @return the age
 */
public int getAge() {
 return age;
}
/**
 * @param age the age to set
 */
public void setAge(int age) {
 this.age = age;
}
/* (non-Javadoc)
 * @see java.lang.Object#clone()
 */
@Override
protected Object clone() throws CloneNotSupportedException {
 // TODO Auto-generated method stub
 return super.clone();
} 
}

 二.Scanner:用来创建一个文本扫描器(键盘录入)      

System类中的静态字段:
    1. public static final InputStream in:  标准输入流
    2.  InputStream :字节流 InputStream is = System.in ;  实质:抽象类多态
    3.public static final OutputStream out:  标准输出流

开发步骤:
                       (1)创建键盘录入对象            (2)录入数据               (3)输出

      Scanner sc = new Scanner(System.in) ;          需要倒包

常用方法：

      判断的功能:
          细节:可以添加逻辑判断
          hasNextXXX(); 在录入数据之前,加上判断功能,判断是否由下一个可以录入的XXX类型的数据
          nextXXX();//通过录入获取这个int类型的数据

                                         java.util.InputMismatchException:输入和想到的数据不匹配

         Scanner类中的注意事项:
               先录入int类型的数据,在录入String类型数据,第二次录入的数据没有接收到,直接输出结果了,由于"回车"才能接收数据    回车换行符导致的!
     解决方案:
                   在第二次录入String类型数据之前,需要重新创建键盘录入对象录入String类型

示例代码1

      

package org.lemon.Scanner;

import java.util.Scanner;

public class ScannerDemo1 {
  public static void main(String[] args) {
 // 创建Scanner 对象
   Scanner sc = new Scanner(System.in);
   //录入数据
 /*  int a = sc.nextInt();
   System.out.println("a:"+a);*/
  
   //添加 逻辑判断
   if(sc.hasNextInt()) {
    int a = sc.nextInt();
    System.out.println("a:"+a);
   }else {
    System.out.println("输入不匹配");
   }
  

}
}

示例代码2

     

       

package org.lemon.Scanner;

import java.util.Scanner;

public class ScannerDemo2 {
  public static void main(String[] args) {
  //创建Scanner 对象
   Scanner sc = new Scanner(System.in);
 //录入数据
   int a = sc.nextInt();
 
 //创建Scanner 对象
   Scanner sc2 = new Scanner(System.in);
   String b = sc2.nextLine();
   System.out.println("a:"+a+",b:"+b);
   }
}

示例代码3

    

package org.lemon.Scanner;

import java.util.Scanner;

// 用户登录
public class Test {
  public static void main(String[] args) {
  //创建 用户  密码
   String name = "abcd";
   String passWord = "abcd";
  
   for(int i = 0;i < 3;i++) {
    //创建 键盘录入
    Scanner sc = new Scanner(System.in);
    //输入
    System.out.println("输入用户名");
    String newName = sc.nextLine();
    System.out.println("输入密码");
    String newPassWord = sc.nextLine();
   
    if(name.equals(newName) && passWord.equals(newPassWord)) {
     System.out.println("登录成功，游戏开始");
     GuessNumberGame start;
     break;
    }else {
     if((2-i)==0) {
      System.out.println("你的账户已被冻结");
     }else {
     System.out.println("还有"+(2-i)+"次机会，好好把握");
    }
   }
}
}
}

package org.lemon.Scanner;

import java.util.Scanner;

public class GuessNumberGame {
 
 //构造方法私有
 private GuessNumberGame() {
  
  }
    public static void start(){
     //产生随机数
     int number = (int) (Math.random()*100 +1);
  
  //定义一个统计变量
  int count = 0 ;
  
  while(true) {
    //创建键盘录入
   Scanner sc = new Scanner(System.in);
   System.out.println("输入一个数据:");
   int guessNumber = sc.nextInt() ;
   
  //统计变量++
   count ++ ;
   
   if(guessNumber < number) {
    System.out.println("你猜小了");
   }else if(guessNumber > number) {
    System.out.println("你猜大了");
   }else {
    System.out.println("你牛逼"+count+"次猜对了");
    break;
   }
  }
    }
}

三 String类

          （代表字符串   字符串一旦被赋值,其值不能再改变）

   构造方法:

         String():表示一个空字符序列。
         public String(byte[] bytes,Charset ch):默认字符集(编码格式):GBK,如果是GBK格式,可以不写第二个参数
         public String(byte[] bytes,int index,int length):将部分字节数组构造成一个字符串
         public String(char[] value):将字符数组构造成一个字符串
         public String(char[] value,int index,int length):将部分的字符数组构造成一个字符串
         public String(String original):通过字符串常量构造一个字符串对象

                  获取字符串的长度功能:      public int length()

编码:
         把能看懂的东西转换成一个看不懂的东西:String----->byte[]:public byte[] getBytes(String charsetName)   

解码:
         把当前的byte[]转成能看懂的东西(String):byte[]----->String  :public String(byte[] bytes,CharsetName ch)
 

String类的获取功能:
    int length()  :获取字符串长度功能
    char charAt(int index):返回的是索引处对应的字符
    int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引

    int indexOf(String str):返回指定子字符串在此字符串中第一次出现的索引
    int indexOf(int ch,int fromIndex):返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
    int indexOf(String str,int fromIndex):返回在此字符串中第一次出现指定字符串处的索引，从指定的索引开始搜索
  
    String substring(int start):从指定位置开始截取字符串,默认截取到末尾
    String substring(int start,int end):从指定位置开始截取到指定位置结束,包前(start索引)不包后(end索引)

String类的转换功能
         byte[] getBytes():将字符串转换字节数组
         char[] toCharArray():将字符串转换成 字符数组 (开发中经常使用)
         static String valueOf(char[] chs):将字符数组转换成字符串
         static String valueOf(int i):将一个int类型的数据转换成字符串
   注意:
         String类中的valueOf()可以将任何数据类型转换成字符串
         String toLowerCase():将字符串全部转成小写
         String toUpperCase():将字符串全部转换成大写
         String concat(String str):字符串拼接方法

   替换功能:
         public String replace(char oldChar,char newChar):将字符串中某一个字符用新的字符替换
         public String replace(String oldStr,String newStr):将字符串中某一个子字符串用新 的字符串去替代
        去除字符串两端空格:   public String trim()
         两个字符串进行比较:
         public int compareTo(String anotherString)  是Comparable接口中的方法(该接口可以实现一个自然排                Comparator接口可以比较器排序

四，方法递归

    1.需要定义方法

    2.必须有出口条件

    3.必须有某一种规律

五.StringBuffer:线程安全的可变字符序列

      常用的功能:
               public int length():获取字符串长度数
               public int capacity():获取当前字符串缓冲区的容量

 

    StringBuffer的构造方法:
               public StringBuffer ()构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符
               public StringBuffer(int capacity)构造一个不带字符，但具有指定初始容量的字符串缓冲区
               public StringBuffer(String str)
               构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。该字符串的初始容量为 16 加上字符串参数的长度

package org.lemon.StringBuffer;

public class StringBufferDemo {
 public static void main(String[] args) {
//构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符 
 StringBuffer sb = new StringBuffer() ;
 System.out.println("sb.length:"+sb.length());
 System.out.println("sb.capacity:"+sb.capacity());//16
 
 
 
 //构造一个不带字符，但具有指定初始容量的字符串缓冲区
 StringBuffer sb2 = new StringBuffer(50) ;
 System.out.println("sb2.length:"+sb2.length());
 System.out.println("sb2.capacity:"+sb2.capacity());//50
 
 
 
 StringBuffer sb3 = new StringBuffer("hello") ;
 System.out.println("sb3.length:"+sb3.length());
 System.out.println("sb3.capacity:"+sb3.capacity());
}
}

  和添加有关的方法
              public StringBuffer append(int/String/char/boolean/double/float....):当前这个方法追加,给缓冲中追加数据,返回字符串缓冲区本身(经常使用的)
              public StringBuffer insert(int offset,String str):在某一个位置处去插入str这个字符串,返回字符串缓冲区本身

package org.lemon.StringBuffer;

  public class StringBufferDemo2 {
  public static void main(String[] args) {
  
 //创建字符串缓冲区对象
  StringBuffer sb = new StringBuffer() ;
  
 //追加数据
  sb.append("hello") ;
  sb.append(true) ;
  sb.append(13.45) ;
  sb.append('A') ;
  sb.append(12.56F);
  
 //链式编程
  sb.append("hello").append(true).append(13.45).append('A').append(12.56F);
  
 //public StringBuffer insert(int offset,String str):在某一个位置处去插入str这个字符串,返回字符串缓冲区本身
  
  sb.insert(5, "world") ;
 
  System.out.println("sb:"+sb);
 }
}

  删除功能:
              public StringBuffer deleteCharAt(int index):删除指定位置处的字符,返回的是字符串缓冲区本身!
              public StringBuffer delete(int start,int end):删除从指定位置开始到指定位置结束的字符,返回的是字符串缓冲区本身!

   反转功能:
              public StringBuffer reverse():将此字符串中的字符序列直接反转

package org.lemon.StringBuffer;

import java.util.Scanner;

public class StringBufferDemo3 {
  public static void main(String[] args) {
  //创建键盘录入对象
   Scanner s = new Scanner(System.in);
  
   //录入数据
   System.out.println("输入一个字符串:");
   String line = s.nextLine();
  
   //创建缓冲区对象
   StringBuffer sb = new StringBuffer(line);
  
   //实现反转
   String result = sb.reverse().toString();
   System.out.println("result:"+result);
}
}

   替换功能:
              public StringBuffer replace(int start, int end,String str)      从指定位置开始到指定位置结束的字符用str子字符串去替代

package org.lemon.StringBuffer;

public class StringBufferDemo4 {
  public static void main(String[] args) {
 //创建录入对象
   String s = "asdfghjk";
   //创建字符串缓冲区
   StringBuffer sb = new StringBuffer(s);
  
 //public StringBuffer replace(int start, int end,String str)
   sb.replace(2, 6, "我爱你");
   System.out.println("sb:"+sb);
}
 
}

   截取功能:
              public String substring(int start):从指定位置默认截取到末尾,返回值是一个新的字符串
              public String substring(int start,int end):从指定位置开始截取到指定位置结束,包前不包后,返回一个新的字符串

package org.lemon.StringBuffer;

public class StringBufferDemo5 {
  public static void main(String[] args) {
 //创建缓冲区
   StringBuffer sb = new StringBuffer();
  
   //添加
   sb.append("abc");
   sb.append("qaqaqa");
  
 //public String substring(int start)
   String s = sb.substring(2);
   System.out.println("s:"+s);
  
 //public String substring(int start,int end)
   String s1 = sb.substring(1, 7);
   System.out.println("s1:"+s1);
   }
}

六. Integer

        自动拆装箱         将基本类型--->引用类型的作用:就是为了和String类型作为转换

    Integer类的构造方式:
                public Integer(int value):将一个int类型的数据封装成一个引用类型
                public Integer(String s):将一个字符数类型封装成一个Integer类型
                注意事项:  该字符串必须是数字字符串!,否则:java.lang.NumberFormatException

七.Character

          类在对象中包装一个基本类型 char 的值。Character 类型的对象包含类型为 char 的单个字段

  构造方法:
                public Character(char value)构造一个新分配的 Character 对象，用以表示指定的 char 值。

 

  判断功能:
                public static boolean isLowerCase(char ch)确定指定字符是否为小写字母。
                public static boolenn isUpperCase(char ch)确定指定字符是否为大写字母
                public static boolean isDigit(char ch)确定指定字符是否为数字。
  
  转换功能:
                public static char toUpperCase(char ch):将指定字符转换成大写
                public static char toLowerCase(char ch):将指定字符转换成小写
                需求:键盘录入一个字符串,统计该字符串中大写字母字符,小写字母字符,数字字符有多少个(不考虑其他字符,使用Character提供的判断功能去完成)

package org.lemon.Character;

import java.util.Scanner;

  public class CharacterDemo {
  public static void main(String[] args) {
   //定义三个统计变量
   int bigCount = 0 ;
   int smallCount = 0 ;
   int numberCount = 0;
   
   //创建键盘录入对象
   Scanner sc = new Scanner(System.in) ;
   
   //录入并接收数据
   System.out.println("请您输入一个字符串:");
   String line = sc.nextLine();
   
   //将字符串转换成字符数组
   char[]  chs = line.toCharArray() ;
   for(int x = 0 ; x < chs.length ; x ++){
    //获取每一个字符
    char ch = chs[x] ;
    
    if(Character.isUpperCase(ch)){
     bigCount ++ ;
    }else if(Character.isLowerCase(ch)){
     smallCount ++ ;
    }else if(Character.isDigit(ch)){
     numberCount ++ ;
    }
   }
   System.out.println("大写字母字符共有:"+bigCount+"个");
   System.out.println("小写字母字符共有:"+smallCount+"个");
   System.out.println("数字字符共有:"+numberCount+"个");
  }
 }

八.冒泡排序

                两两比较,大的往后放,第一次比完,最大值出现在最大索引处,依次进行这样的比较