day10java基础

最新推荐文章于 2024-06-23 19:09:33 发布

canoe_df

最新推荐文章于 2024-06-23 19:09:33 发布

阅读量217

点赞数

本文链接：https://blog.csdn.net/canoe_df/article/details/78404834

版权

day10
一.Object类：
1.类Object是类层次结构的根类，每个类都使用Object作为超类（父类）。所有对象（包括数组）都实现这个类的方法。
（1）public int hashCode()返回该对象的哈希码值
hashCode（）：通过哈希算法（哈希表：hashtable）---->地址值（不是实际意义上的地址值）
（2）public final Class getClass（）返回此Object的运行时类（JAVA反射机制中讲）
public String getName（）以String的形式返回此Class对象所表示的实体（类、接口、数组类、基本类型或void名称）
例子：

public class ObjectDemo {
	
	public static void main(String[] args) {
		
		//创建学生对象
		Student s1 = new Student() ;
		System.out.println(s1.hashCode());//1460821906
		
		Student s2 = new Student()  ;
		System.out.println(s2.hashCode());//2045891656
		
		Student s3 = new Student() ;
		System.out.println(s3.hashCode());
		
		
//		System.out.println("hello".hashCode()) ;
		
//		public final Class getClass()返回此 Object 的运行时类
		Class c1 = s1.getClass() ;
//		System.out.println("c1:"+c1);//class org.westos.object_01.Student
		//public String getName():获取当前正在运行的这类的全路径名称!
		String name = c1.getName() ;
		System.out.println("name:"+name);//org.westos.object_01.Student :全路径名称
										//org.westos.object_01.Student
	}
}
ublic class Student extends Object{
	
}

（ 3）public String toString();返回该对象的字符串表示(建议所有的子类都重写此方法)
Integer类中有一个方法：
public static String toHexString(int i):将一个int类型的数据转换成一个十六进制的字符串表现形式
如果直接输出对象名称，想要显示当前对象的成员变量的值，那么必须重写Object类中的toStrinng()方法

在源码里，toString<==>对象名.getClass().getName()+"@"+Integer.toHexString(对象名.hashCode())

public static void main(String[] args) {
		//创建一个学生对象
		Student s1 = new Student("高圆圆",27) ;
			
		//直接输出对象名称
		/*System.out.println("s1:"+s1);//org.westos.object_02.Student@7439aca7
		//public String toString()
		System.out.println("toString():"+s1.toString());//org.westos.object_02.Student@7439aca7
		System.out.println("--------------------------");*/
		
		/**
		 * 通过查看toString()源码:
		 *  public String toString() {
        		return this.getClass().getName() + "@" + Integer.toHexString(this.hashCode());
    		}
    		
    		toString()<==> 对象名.getClass().getName() +"@" +Integer.toHexString(对象名.hashCode())
		 */
		
		System.out.println(s1.getClass().getName()+"@"+Integer.toHexString(s1.hashCode()));
//		System.out.println(s1.toString());
		//org.westos.object_02.Student@28169674
		//org.westos.object_02.Student@28169674
		
		//直接对象名称,想要显示成员变量的值,怎么办?
                //去student类里面重写toString（）方法
//		System.out.println(s1);
		Student s2 = new Student("高圆圆", 27) ;
		System.out.println("s2:"+s2);
		System.out.println(s1==s2);		
	}
}

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;
	}
	//当前toString()是自己去写的
/*	@Override
	public String toString() {
		return name+"---"+age;
	}*/
	
	//alt+shift+s->s
	//自动生成即可!
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	
	
	
}

（4）public boolean equals(Object obj):指示其它某个对象是否与此对象“相等”

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

使用工具自动生产equals()方法：

javascript:Array对象,Number对象,String对象,valueOf():====>s1.valueOf(s2) ;比较是内容是否相同

例子：

public class ObjectDemo {
	
	public static void main(String[] args) {
		
		//创建学生对象
		Student s1 = new Student("高圆圆", 27) ;
		Student s2 = new Student("高圆圆",27) ;
		System.out.println(s1==s2);//false
		System.out.println("------------------");
		Student s3 = s1 ;
		System.out.println(s1==s3);//true
		System.out.println("-------------------");
		System.out.println(s1.equals(s2));//由于重写Object中的equals()方法,所以比较的是对象的内容是否相同!
		
		/**
		 * equals()方法的源码
		 *   public boolean equals(Object obj) {
        	return (this == obj);
    	}
    		由于Object类中的equals()方法底层是通过"=="来实现的,所以默认比较的是地址值,如果想比较内容是否相同,需要重写equals()方法
		 * */
	}
}

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;
	}

	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;
	}

	//toString()
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	
	
	//重写了Object类中的equals()方法
	@Override
	public boolean equals(Object obj) { //Studnet s2 = new Student() ;
		if (this == obj)
			return true;
		if (obj == null)  //当前传入过来的对象是否为空
			return false;
		if (getClass() != obj.getClass())	//this.getClass() != s2.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;
	}
	
	
	/**
	 * 对象名  instanceof 类:判断该对象是否是该类的一个实例
	 * */

（5）protected void finalize( )throws Throwable:

当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法，但是，什么时候调用垃圾回收器不确定。

System类中的一个方法：

public void gc（）：运行垃圾回收器，这个垃圾回收器最终调用的就是finalize（）方法。

（6）protected Object clone()throws CloneNotSupportedException{ }:创建并返回此对象的一个副本

注意事项：

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

例子：

public class ObjectDemo {
	
	public static void main(String[] args) throws CloneNotSupportedException {//该异常是编译时期异常
		//创建s1这个学生对象
		Student s1 = new Student() ;
		s1.setName("高圆圆") ;
		s1.setAge(27) ;
		
		System.out.println(s1.getName()+"---"+s1.getAge());
		
		//复制s1这个对象
		Object obj = s1.clone() ;
		//向下转型:
		Student s2 = (Student) obj;
		System.out.println(s2.getName()+"---"+s1.getAge());
		System.out.println("----------------------");
		
		//没有讲clone方法之前:
		Student s3 = s1; //把s1地址值赋值s3对象,s3指向s1的堆内存中的地址值
		System.out.println(s3.getName()+"---"+s3.getAge());
	}
}

public class Student implements Cloneable{
	
	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;
	}
	
	
	//重写Object类中clone()
	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}
	
	
}

二.Scanner

  1.Scanner:用来创建一个文本扫描器(键盘录入)
2.java高级特性:IO流(后面讲)
BufferReder:字符缓冲流来键盘录入
java.util.Scanner;s
Scanner sc = new Scanenr(System.in);

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

4.开发步骤:
1)创建键盘录入对象
2)录入数据
3)输出
5. Scanner类中常用的方法:
   判断的功能:
   细节:可以添加逻辑判断
hasNextXXX(); 在录入数据之前,加上判断功能,判断是否由下一个可以录入的XXX类型的数据
   nextXXX();//通过录入获取这个int类型的数据
举例:
public boolean hasNextInt()
nextInt();

nextInt():录入int类型的数据
   nextLine():录入一个字符串类型

异常： java.util.InputMismatchException:输入和想要的数据不匹配

例子：

public class ScannerDemo2 {
	
	public static void main(String[] args) {
		//创建键盘录入对象
		
		Scanner sc = new Scanner(System.in) ;
		
		if(sc.hasNextInt()){
			//是否有下一个可以录入的int类型的数据
			//录入数据
			int a = sc.nextInt() ;
			System.out.println("a:"+a);
		}else{
			//错误提示
			System.out.println("录入的数据类型和想要的不匹配!");
		}
		
		//java.util.InputMismatchException:输入和想到的数据不匹配
		
	}
}

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

例子：

public class ScannerDemo3 {
	
	public static void main(String[] args) {
		
		//键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//先录入两个int类型的数据
		/*int a = sc.nextInt() ;
		int b = sc.nextInt() ;
		System.out.println("a:"+a+",b:"+b);*/
		
		//录入两个String类型的数据
		//hasNextLine
		/*String a = sc.nextLine() ;
		String b = sc.nextLine() ;*/
		
		//先录入String类型的数据,在录入int类型的数据
		/*String a = sc.nextLine() ;
		int b = sc.nextInt() ;*/
		
		//先录入int类型,再录入String类型
		int a = sc.nextInt() ;
//		String b = sc.nextLine() ;
		String b = sc.next() ;
		/*
		int a = sc.nextInt() ;
		//创建键盘录入对象
		Scanner sc2 = new Scanner(System.in) ;
		String b = sc2.nextLine() ;
		*/
		
		
		System.out.println("a:"+a+",b:"+b);
	}
}

三.String类:代表字符串。

1.Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现;字符串一旦被赋值,其值不能再改变
2.String类常用的构造方法:
   （1）String():表示一个空字符序列。
（2） public String(byte[] bytes,Charset ch):默认字符集(编码格式):GBK,如果是GBK格式,可以不写第二个参数
   （3）public String(byte[] bytes,int index,int length):将部分字节数组构造成一个字符串
   （4）public String(char[] value):将字符数组构造成一个字符串
   （5）public String(char[] value,int index,int length):将部分的字符数组构造成一个字符串
   （6）public String(String original):通过字符串常量构造一个字符串对象
（7）获取字符串的长度功能:
   public int length()
面试题:
   数组中有没有length(),字符串(字符串缓冲区:StringBuffer)中没有length(),集合中有没有length()(集合后面讲)?
   数组没有length(),length属性
   字符串中有length()
   集合中没有length(),获取集合中元素数量:size()
编码和解码:一定要保证编码格式一致
   编码:
把能看懂的东西转换成一个看不懂的东西:String----->byte[]:public byte[] getBytes(String charsetName)
解码:
   把当前的byte[]转成能看懂的东西(String):byte[]----->String :public String(byte[] bytes,CharsetName ch)

例子：

public class StringDemo {
	
	public static void main(String[] args) throws UnsupportedEncodingException {
		//创建一个String对象
		String s1 = new String() ;
		System.out.println("s1.length():"+s1.length());
		System.out.println("s1:"+s1);
		System.out.println("----------------------");
		
		//public String(byte[] bytes,Charset ch):默认字符集(编码格式):GBK,如果是GBK格式,可以不写第二个参数
		//创建一个字节数组
		byte[] bys = {97, 98, 99, 100, 101} ; 
		String s2 = new String(bys) ;//字节的值要找它对应的ASCII码表中的字符
		System.out.println("s2:"+s2);
		//abcde
		System.out.println("s2.length():"+s2.length());//5
		System.out.println("----------------------");
		
		/**
		 * 编码和解码
		 */
		//定义一个字符串:
		String s = "你好" ;
		//[-60, -29, -70, -61]  :GBK
		//[-28, -67, -96, -27, -91, -67]:utf-8
//		byte[] bys2 = s.getBytes("utf-8") ;//编码:以:GBK格式编码     utf-8:一个中文:对应三个字节
		byte[] bys2 = s.getBytes() ;
//		System.out.println(bys2);
		//Arrays:数组工具类:toString(byte[] bys)
		System.out.println(Arrays.toString(bys2));
		
		System.out.println("-------");
//		String str = new String(bys2, "utf-8") ;
		String str = new String(bys2) ;
		System.out.println("str:"+str);
		
		System.out.println("------------------");
		//public String(char[] value):将字符数组构造成一个字符串
		//定义一个字符数组
		char[] chs = {'我','爱','高','圆','圆'} ;
		String s3 = new String(chs) ;
		System.out.println("s3.length():"+s3.length());
		System.out.println("s3:"+s3);
		
		System.out.println("--------------------");
		String s4 = new String(chs, 1, 4) ;
		System.out.println("s4:"+s4);
		System.out.println("s4.length():"+s4.length());
		
		System.out.println("--------------------");
		//public String(String original):通过字符串常量构造一个字符串对象
		String s5 = new String("hello") ;
		System.out.println("s5:"+s5);
		System.out.println("s5.length():"+s5.length());
		
		
		String s6 = "hello" ;
		System.out.println("s6:"+s6);
		System.out.println("s6.length():"+s6.length());
		
		
	}
}

3.字符串的一个特点:一旦被赋值,其值不能被改变(不可变的字符序列)。

面试题:
String s = "hello"和String s = new String("hello") 两个有什么区别?分别创建了几个对象

第一个创建了一个对象
第二个s创建两个对象(堆内存中有new String(),然后字符串常量池中也有这样一个字符串常量(开辟空间的地址))

例子：

public class StringDemo {
	public static void main(String[] args) {
		
		String s = "hello" ;	// String s = "abc" ;
		
		/*s += "world" ;
		
		System.out.println("s:"+s);*/
		
		change(s) ;
		
		//输出字符串变量
		System.out.println("s:"+s);//hello
		
	}

	public static void change(String s) {//String类型作为形式参数和基本数据类型的效果一样
		
		s += "javaweb" ;
	}
}

4.String类的中常用的判断功能:
* （1）boolean equals(Object obj):当前该对象是否obj这个对象是否相等;
（2）boolean equalsIgnoreCase(String str):比较字符串是否相等,忽略大小写
（3）boolean contains(String str):判断str这个字符串是否包含在当前字符串中
（4）boolean startsWith(String str):是否以str子字符串开头
（5）boolean endsWith(String str):判断是否以str子字符串结尾
（6）boolean isEmpty():判断字符串是否为空

String s = "" ;空字符
String s = " " ;字符串"空格"
String s = null ;当前字符串对象为空

例子：

 public class StringDemo {
	
	public static void main(String[] args) {
		
		//定义一个字符串
		String s1 = "helloworld" ;
		String s2 = "HelloWorld" ;
		
//		boolean equals(Object obj):当前该对象是否obj这个对象是否相等;String重写equals(),比较的是两个字符串的内容是否相同
		System.out.println("equals:"+s1.equals(s2));
		//boolean equalsIgnoreCase(String str):比较字符串是否相等,忽略大小写
		System.out.println("equalsIgnoreCase:"+s1.equalsIgnoreCase(s2));
		
		//boolean contains(String str):判断str这个字符串是否包含在当前字符串中
		System.out.println("contains:"+s1.contains("owo"));
		System.out.println("contains:"+s1.contains("ak47"));
		
		//boolean startsWith(String str):是否以str子字符串开头
		System.out.println("starsWith:"+s1.startsWith("hel"));
		//boolean endsWith(String str):判断是否以str子字符串结尾  自己测试
		
		//boolean isEmpty():判断字符串是否为空
		System.out.println("isEmpty:"+s1.isEmpty());
	}
}

5.字符串变量相加,先开辟空间,在相加
字符串常量相加:首先在字符串常量池找,有没有当前这个常量值,有,就直接返回,没有,需要创建!

例子：

public class StringDemo2 {
	
	public static void main(String[] args) {
		String s1 = "hello";  
		String s2 = "world";
		String s3 = "helloworld";
		System.out.println(s3 == s1 + s2);// false
		//System.out.println(s3 == (new StringBuilder(String.valueOf(s1))).append(s2).toString());
//		s1+s2 ====>new String("helloworld")
		System.out.println(s3.equals((s1 + s2)));//true , 


		System.out.println(s3 == "hello" + "world");//true
		System.out.println(s3.equals("hello" + "world"));//true
		
		/**
		 * 通过反编译工具查看第三个输出语句:
		 * System.out.println(s3 == "helloworld");
			System.out.println(s3.equals("helloworld"));
		 * */
	}
}

6.String类的获取功能:
int length() :获取字符串长度功能
char charAt(int index):返回的是索引处对应的字符
int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引
为什么这里的字符用int来定义: 97 'a'
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索引)

例子：

public class StringDemo {
	
	public static void main(String[] args) {
		//定义一个字符串:
		String str = "helloworld" ;
		
		//int length()	:获取字符串长度功能
		System.out.println("length:"+str.length());
		
		//char charAt(int index):返回的是索引处对应的字符
		System.out.println("charAt:"+str.charAt(1));
		System.out.println("charAt:"+str.charAt(8));
		System.out.println("-------------------------------");
		
		//int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引
		System.out.println("indexof:"+str.indexOf('l'));
		System.out.println("indexof:"+str.indexOf('k'));//-1
		
		//int indexOf(String str):返回指定子字符串在此字符串中第一次出现的索引
		System.out.println("indexOf:"+str.indexOf("owo"));
		System.out.println("-------------------------------");
		//int indexOf(int ch,int fromIndex):返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
		System.out.println("indexOf:"+str.indexOf('l', 4));
		
		//int indexOf(String str,int fromIndex):返回在此字符串中第一次出现指定字符串处的索引，从指定的索引开始搜索 (自己测试)
		
		//String substring(int start):从指定位置开始截取字符串,默认截取到末尾(返回一个新的字符串,不再是字符串本身!)
		System.out.println("substring:"+str.substring(5));
		
		//String substring(int start,int end):从指定位置开始截取到指定位置结束,包前(start索引)不包后(end索引)
		System.out.println("substring:"+str.substring(4, 8));//owor
	}
}

7.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 class StringDemo {
	
	//构造方法:
	//构造方法不能使用递归
	/*public StringDemo(){
		StringDemo();
	}*/
	
	public static void main(String[] args) {
		//定义一个字符串
		String s = "JavaSE" ;
		
		//byte[] getBytes():将字符串转换字节数组
		byte[] bys = s.getBytes() ;
		//遍历字节数组
		for(int x = 0 ; x < bys.length ; x++){
			System.out.println(bys[x]);
		}
		System.out.println("---------------------");
		
		//char[] toCharArray():将字符串转换成 字符数组
		char[] chs = s.toCharArray() ;
		for (int x = 0; x < chs.length; x++) {
			System.out.println(chs[x]);
		}
		
		System.out.println("---------------------");
		
		//static String valueOf(char[] chs):将字符数组转换成字符串
		String s2 = String.valueOf(chs) ;
		System.out.println("s2:"+s2);
		
		//static String valueOf(int i):将一个int类型的数据转换成字符串
		String s3 = String.valueOf(100) ;
		System.out.println("s3:"+s3);
		
		//String toLowerCase():将字符串全部转成小写
		System.out.println("toLowerCase:"+s.toLowerCase());
		//String toUpperCase():将字符串全部转换成大写
		System.out.println("toUpperCase:"+s.toUpperCase());
		
		//String concat(String str):字符串拼接方法
		String s4 = "hello" ;
		String s5 = "world" ;
		System.out.println("contact:"+s4.concat(s5));
		
		String s6 = "java" ;
		s6 += "web" ;
		System.out.println("s6:"+s6);

8.方法嵌套
Math.max(Math.max(a,b),c);

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

三个条件:
1)需要定义个方法
2)方法必须有出口条件
3)必须有某一种规律
public void show(int n){

   if(n<0){
   System.exit(0) ; //让jvm退出,程序结束
   }

   System.out.println(n) ;
show(--n) ;
}
* */
System.out.println("--------------------");
//需求:求5的阶乘
//5! = 5 * 4 * 3 * 2 * 1 ;
//5! = 5 * 4! ;
int jc = 1 ;
//循环思想
for(int x = 2 ; x <=5 ; x ++){
jc *= x;
}
System.out.println("5的阶乘是:"+jc);
System.out.println("-------------------------");
//使用递归的思想:
//需要定义个方法
System.out.println("5的阶乘是:"+jieCheng(5));
}
/**
* 明确返回值类型:
* int类型
* 参数类型:int类型的值
*
* 2)出口条件:
* if(n==1){
* return 1 ;
* }
*
* 3)要有规律
* if(n!=1){
* return n* 方法名(n-1);
* }
* */
public static int jieCheng(int n){

if(n==1){
return 1 ;
}else{
return n* jieCheng(n-1) ; //5 * 4 * 3 * 1 *１　
}
}
}

canoe_df

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
day10java基础

day10一.Object类： 1.类Object是类层次结构的根类，每个类都使用Object作为超类（父类）。所有对象（包括数组）都实现这个类的方法。（1）public int hashCode()返回该对象的哈希码值 hashCode（）：通过哈希算法（哈希表：hashtable）---->地址值（不是实际意义上的地址值）（
复制链接

扫一扫