Java学习lesson 10

Posted 2020-10-15

API(应用程序编程接口)

*  public final Class getClass();//返回Object的运行类（java的反射机制学）

*  Class类中有一个类

       *public String getName();//以String类型返回它所表示的实体（获取当前正在运行的类         的全路径）

*  Integer类中有一个方法

   public  static String toHexString(int i);//将一个int类型的数据转换成一个人十六进制的    字符串表示形式   

*  Object类：

   类层次的根类。所有的对象（包括数组，都实现这个类的方法）

       *  public int hashCode();

          返回该对象的哈希码值

          hashCode------->通过哈希算法（哈希表：hashtable）------>地址值（不是实际意义           上的地址）

    

       *  toString();

          返回对象的一个字符串表示（返回以文本方式表式表示的一个次对象的字符串）

          建议所有的子类都重些这个方法：

          toString();源码：

          public String toString(){

            return getClass().getName()+"@"+Integer.toHexString（hashCode（））；

           }//隐藏this

           toString()<==>对象名。                  getClass().getName()+"@"+Integer.toHexString（hashCode（））

如果直接对象名称想要显示成员变量的值，必须重些Object类中的toString方               法//Alt+Shift+b----->s(自动生成)

package object;

public class Student extends Object {
	private String name;
	private int age ;
	
	public Student() {
		super();
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	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;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
		

}


//测试类
public class ObjectDemo {
	public static void main(String[]args){
		
		
		Student st=new Student();
		System.out.println(st.hashCode());//每次运行结果不相同
		System.out.println("hello".hashCode());//字符串的hashCode值每次运行结果不变
		
	    System.out.println(st.getClass());//返回Object的运行类
	    System.out.println(st.getClass().getName());//获取全路径名称
	    Student st1=new Student("弋痕夕",24);
	  //System.out.println(st1.toString());如果不重写toString()
	  //这个方法就相当于st.getClass().getName()+"@"+Integer.toHexString（hashCode（））
      //结果是[email protected]
	    System.out.println(st1.toString());//重写过后运行结果如下
	}
}

//运行结果

            

        *  x.equals（y）//返回值为boolean类型

           “==”和equals（）方法的区别？

           “==”默认比较地址

            equals（）方法底层是通过“==”来实现的；默认比较的是两个对象的地址值，如             重写equals方法则比较的是两个对象的内容是否相同

            源码：

            public boolean equals(Object obj){

                return(this==obj);

            } 

package object;

public class Student1 {
	private String name;
	private int age ;
	
	public Student1() {
		super();
	}
	public Student1(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	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;
	}

	//Shift+Alt+s——>h快捷键重写equals()方法
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student1 other = (Student1) 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;
	}
}


public class EqualsDemo {
	public static void main(String[] args){
		//创建两个对象
		Student1 st=new Student1("天净沙",45);
		Student1 st1=new Student1("天净沙",45);
		
		System.out.println(st==st1);//“==”默认比较的是两个对象的地址：false
		Student1 st2=st;//将st指向的地址值赋给st2；所以st与st2指向同一个地址
		System.out.println(st==st2);
		
	       //System.out.println(st.equals(st1));底层是由"=="实现，不重写则等价于“==”：false
		System.out.println(st.equals(st1));//重写后默认this.变量：表示当下传入的值所以返回true
	}

	
	
}

//运行结果

        *  protected void finalize()throws Throwable:当垃圾回收器确定不存在对该对象的           更多引用时，由对象的垃圾回收器调用此方法,但是,什么时候调用垃圾回收器

           不确定;

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

                throws CloneNotSupportedException

           注意事项:

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

* Scanner类：

          创建文本扫描器（键盘录入）

          Scanner sc=new Scanner(System.in);（创建录入对象）

        *   开发步骤：

                    创建录入对象

                    录入数据

                    输出

        *   nextInt();录入int类型

           nextLine();录入一个字符串类型

           有时候录入时会出现异常：java.util.InputMismatchException.(输入和想得到的                                                   数据类型不匹配)

        *   public static final InputStream in;(标准输入流)

        *   public static final OutputStream out;(标准输出流)

        *   hasNeatXX();在录入之前，加上判断功能，判断是否有下一个可以录入的XX类型的数                    据

  *Scanner类的注意事项：

        先录入int；类型数据在录入String类型数据，第二次录入没有接收到，直接输出了结果

        这是因为再输入一次后回车才能输入第二次，由于第二次输入的是字符串，回车会导致第

        二次输入失败。

        解决方案：

                在第二次输入前重新创建键盘录入对象

package scanner;

import java.util.Scanner;

public class ScannerDemo {
	public static void main(String[] args){
		Scanner sc=new Scanner(System.in);
		System.out.println("请输入字符串：");
		String str=sc.nextLine();//先录入String后录入int类型,没有问题
		System.out.println("请输入整形数：");
		int num=sc.nextInt();
		System.out.println(str+"---"+num);
		System.out.println("----------------");
		
		System.out.println("请输入整形数：");
		int num1=sc.nextInt();
		System.out.println("请输入第二个整形数：");
		int num2=sc.nextInt();
		System.out.println(num1+"---"+num2);
		System.out.println("----------------");
		
		System.out.println("请输入整形数：");
		int num3=sc.nextInt();//先录入int后录入String,由于回车才能接收数据的原因直接输出int类型的值
		System.out.println("请输入字符串：");
		String str1=sc.nextLine();
		System.out.println(num3+"---"+str1);
		System.out.println("----------------");
		
		System.out.println("请输入字符串：");
		String str2=sc.nextLine();//正常输入
		System.out.println("请输入第二个字符串：");
		String str3=sc.nextLine();//正常输入
		System.out.println(str2+"---"+str3);
		System.out.println("----------------");
		
		//上述问题的解决方法
		System.out.println("请输入整形数：");
		int num4=sc.nextInt();
		System.out.println("请输入字符串：");
		Scanner sc1=new Scanner(System.in);
		String str4=sc1.nextLine();
		System.out.println(num4+"---"+str4);
		System.out.println("----------------");		
	}

}

 

 *String类型：

             字符串类：所有的字符串字面值（如“abc”“[”……）都作为此类的实例实现

             字符串为常量，创建后其值不可以改变。

package string;

public class StringDemo {
	public static void main(String[] args) {
		//定义一个字符串常量（在字符串常量池中如果有这个字符串则给出它的地址
		//如果没有，就重新定义一个字符串，并给出它的地址）
		String s = "hello" ;

		change(s) ;
		//输出字符串变量
		System.out.println("s:"+s);
		
		s += "world" ;
		//s=“helloword”；并没有改变常量池中的“hello”，是在常量池中重新开辟
		//了空间存新的放字符串“helloword”，并将他的地址赋给s；
		
		System.out.println("s:"+s);//输出s为helloword
		
	}

	public static void change(String s) {
		//String类型作为形式参数和基本数据类型的效果一样，无论对形参进行什
		//么样的操作都不会对实参产生影响
		s += "javase" ;
	}
}

  

       *String类常用的构造方法：

           public 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()

 

  *面试题：

         *数组中有没有length（）有length属性，（字符串缓冲区：StringBuffer）中没有             length（），字符串中有length（）

         *String s="hello";和String s=new String("hello");两个有什么区别？分别创建了几           个对象？

          第一个创建了一个对象

          第二个创建了两个对象（堆内存中有new String(),然后字符串常量池中会有一个字符           串常量"hello"）

* String类的转换功能(重点)

      *byte[] getBytes():将字符串转换字节数组

 

       * 编码和解码:一定要保证编码格式一致

        编码:

        把能看懂的东西转换成一个看不懂的东西:

        String----->byte[]:public byte[] getBytes(String  charsetName)

        解码:

        把当前的byte[]转成能看懂的东西(String):

        byte[]----->String:public String(byte[] bytes,CharsetName ch)

  

package string;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class StringDemo3 {
	public static void main(String[] args) throws UnsupportedEncodingException{
	        //创建String对象空参
		String str=new String();
		//获得Str的长度并输出
		System.out.println("str.length():"+str.length());
		System.out.println("str:"+str);
		System.out.println("----------------");
		
		//创建对象并初始化
		String str1=new String("hello");
		System.out.println("str1.length():"+str1.length());
		System.out.println("str1:"+str1);
		
		//定义数组
		byte[] bt={65,66,67,68,69,70,};
		String str2=new String(bt);
		System.out.println("str2:"+str2);
		System.out.println("str2.length()"+str2.length());
		System.out.println("-------------------");
	
		
		String str3="明天有雨";
		byte[] bt2=str3.getBytes("utf-8");
		byte[] bt3=str3.getBytes();
		
		//编码
		System.out.println(bt2);//输出一个地址值，原因是没有重toString方法
		//Arrays.toString();将变量转化成字符串形式；源代码重写了toString（）；输出bt2的内容
		System.out.println(Arrays.toString(bt2));
		System.out.println(Arrays.toString(bt3));
		System.out.println("-------------------");
		
		//解码
		String str4= new String(bt2) ;//编码格式不匹配；输出乱码
		System.out.println("str4:"+str4);
		String str5=new String(bt2,"utf-8");//使用“utf-8”格式编码后面解码也必须用“utf-8”格式
		System.out.println("str5:"+str5);
		String str6=new String(bt3);//如果使用“GBK”格式编码，则不需要写明第二个参数，它是默认的
		System.out.println("str6:"+str6);			
			
	}
}

      *char[] toCharArray():将字符串转换成 字符数组 (开发中经常使用)

      *static String valueOf(char[] chs):将字符数组转换成字符串

      *static String valueOf(int i):将一个int类型的数据转换成字符串

 注意:

      String类中的valueOf()可以将任何数据类型转换成字符串

      *String toLowerCase():将字符串全部转成小写

      *String toUpperCase():将字符串全部转换成大写

      *String concat(String str):字符串拼接方法

             

package string;

public class StringDemo4 {
	public static void main(String[] args){
		//定义一个字符串
		String str="Helloword";
		System.out.println(str);
		//将字符串转换成 字符数组
		char []ch=str.toCharArray();
		//遍历数组
		for(int i=0;i<ch.length;i++){
			System.out.print(ch[i]+" ");
		}
	    System.out.println("");
		System.out.println("---------------");
		
		//将字符数字转换成字符串
		String str1=String.valueOf(ch);
		System.out.println(str1+" ");
		//将int类型数据转换成字符串
		String str2=String.valueOf(50);
		System.out.println(str2);
		
		//将字符串全部转换成大写
		System.out.println("toUpperCase:"+str.toUpperCase());
		//将字符串全部转换成小写
		System.out.println("toLowerCase:"+str.toLowerCase());
		
		//字符串的拼接
		String str3="---javase";
		System.out.println(str.concat(str3));
	}
	

}

       

方法递归:方法调用本身的一种现象

 

三个条件:

1)需要定义个方法

2)方法必须有出口条件

3)必须有某一种规律

package homework;

public class FactorialDemo {
	public static void main(String[] args){
		int num=10;
		System.out.println("10!="+getSum(num));
		
	}	
    public static int getSum(int num){
    	         // 1！=1   2！=1*2  3！=2！*3   4！=3！*4  5！=4！*5
		//基数从一开始
		int factorial=1;
		//求阶乘的和
		for(int i=1;i<=num;i++)
		{   
			//求阶乘 
		    factorial*=i;
		}
     return factorial;
    } 
		
}