您的位置：首页 > 移动开发 > Objective-C

Object类

2020-07-20 04:17 971 查看

文章目录

  • （二）String类
  • （三）包装类

    • （一）Object类

    （1）Object的概念，子类继承了Object的方法

    1.java.lang.Object是java中所有类的直接父类或者间接父类。
    例子：class A{}
    class B extends A{}
    2.所有类的对象都可以声明成Object引用。
    例子：Object o1=new A()
    Object o2=new B()

    （2）getClass()方法getName()

    getClass()方法：返回一个对象的实际类型，实质上是该对象所对应类的class文件对象

    public class Student {

public static void main(String[] args) {
Student stu=new Student();
stu.hashCode();
Object ob=stu;
//所有类的对象都可以声明成Object引用
Object ob1=new Student();
System.out.println(ob1.getClass());
//getClass()方法，返回一个对象的实际类型，实质上是该对象所对应类的Class文件对象
System.out.println(stu.getClass());
//Class对象，实质是Class文件，即该类编译之后产生的二进制字节码文件
//获取gatClass文件的方法以下两种
//1.通过对象.getClass
Class c1=stu.getClass();
//2.通过类名.Class
Class c2=Student.class;
//getName()f返回Class对象的全类名
System.out.println(c1.getName());
//getSimpleName():返回Class对象的简类名
System.out.println(c1.getSimpleName());
}
public boolean equals(Object obj)
{
return true;
}
}
    输出结果：
ob1.getClass：class com.soft.object.Student
stu.getClass：class com.soft.object.Student
c1.getName：com.soft.object.Student
c1.getSimpleName：Student

    （3）equals()方法hashCode()

    作用：在equsals()方法对于字符串类型（String）的作用是比较两个字符串是否相等，在用到类的实例对象中（Object）的时候未重写的情况下和"=="等价，比较的是两个对象的地址值，在进行Object.equals重写后比较的是2个对象的属性内容是否相等，例：

    public class Animal {

String name;
int age;
//通过含参构造方法传参，更改方法属性。
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
//重写hashCode()函数
//	@Override
//	public int hashCode() {
//		final int prime = 31;
//		int result = 1;
//		result = prime * result + age;
//		result = prime * result + ((name == null) ? 0 : name.hashCode());
//		return result;
//	}
//重写equals()Object函数
//	@Override
//	public boolean equals(Object obj) {
//		if (this == obj)
//			return true;
//		if (obj == null)
//			return false;
//		if (getClass() != obj.getClass())
//			return false;
//		Animal other = (Animal) 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 AnimalTest {
public static void main(String[] args) {

String i="ss";
String j=new String("ss");
Animal ani1=new Animal("mark",12);
Animal ani2=new Animal("mark",12);
System.out.println(j.equals(i));
System.out.println(ani1.equals(ani2));//比较属性是否相等
System.out.println(ani1.hashCode());

}
//手动重写Object，equals()方法此时一定会返回true
//	public boolean equals(Object obj)
//	{
//		return true;
//	}

}
未重写equals()函数以及hashCode(),编译输出的结果：
true
false
2018699554
此时判断字符串为相等，两个实例对象的地址不相等。哈希值为2018699554。
进行重写后输出结果：
true
true
3345410
此时判断字符串为相等，两个实例对象的属性内容相等。哈希值为3345410更加准确。

    （4）toString()方法

    public static void main(String[] args) {

Student stu=new Student();
stu.hashCode();//通过ctrl键可查看方法
Object ob=stu;
Object ob1=new Student();
//toString():Object中方法，输出对象的全类名以及对象的hasCode的十六进制
System.out.println(ob.toString());
System.out.println(stu.toString());
System.out.println(ob1.toString());
}
//重写Object，equals方法
public boolean equals(Object obj){
return true;
}
}
输出结果：
com.soft.object.Student@7852e922
com.soft.object.Student@7852e922
com.soft.object.Student@4e25154f
由结果可知ob，ob1，stu都是指向子类的对象，且ob和stu所存地址一样。
    //在类中重写toString()方法主要作用是返回该对象的所有属性值的字符串形式
@Override
public String toString() {
return "Animal [name=" + name + ", age=" + age + "]";
}
在测试中的输出结果：
Animal [name=mark, age=12]

    （二）String类

    （1）创建一个字符串对象

    String：在遇到双引号（" "）后会在字符串常量池中创建有序的字符序列，是一个常量不可更改。
    两种创建字符串的方式

    • 1.String str="abc"; //声明式创建。默认的创建方式。
-声明式创建字符串的方式，字符串存储的位置在字符串常量池中。
当再次以这种方式创建字符串，则会直接去字符串常量池中进项匹配，如果又就直接引用，没有就直接在字符串常量池中进行创建。
    • 2.String str = new String(“”); //创建String的实例对象，new时会在堆和栈中开辟新的内存地址。栈中存放的是对的首地址，堆中存放的是具体值。

    （2）String类中的常用方法

    1.boolean equals()方法

    public static void main(String[] args) {
String i="ss";
String j=new String("ss");

//	String j=new String("ss");
//	j="ss";
System.out.println(i==j);
System.out.println(j.equals(i));
}
输出结果：
false
true
若将j改变为程序中屏蔽掉的历程此时输出结果：
true
true
说明此时j声明的堆中并未存放东西，当我们再次对j进行赋值时候此时j指向字符串常量池，并未指向堆地址。

    2.char charAt(int pos)//得出pos位置的字符

    3.int length()//得出字符串长度

    4.String[] split()//按照分隔符建立字符串数组

    5.trim()//去掉字符两端空格

    6.Sting substring(int begin,intend)//截取字符串

    7.startsWith(“字符”)//判断字符串是否以"字符"开头。

    8.endsWith(“字符”)//判断字符串是否以"字符"为结尾。

    9.compareTo()和compareTolgnoreCse()//比较字符串

    10.indexOf()//c查找字符或者子串第一次出现的地方

    11.lastindexOf()//查找字符或者子串最后一次出现的地方

    12.substring()/字符串截取

    13.concat()//连接两个字符串，方法之一

    14.replace()//替换，用一个字符在调用字符串中所有出现某个字符的地方进行替换

    这里写一个测试代码，供参考。

    public static void main(String[] args) {
// TODO Auto-generated method stub
String str1="abc";
String str2="abc";
String str3=new String("abc");
//charAt(int):返回指定位置的字符
char c=str1.charAt(1);
System.out.println(c);
//          length():返回字符串 的长度
System.out.println(str1.length());
//split("分隔符"):将字符串按照分隔符分割为一个字符串类型的数组
String str4="What:are:words";
String[] arrays=str4.split(":");
for(String s:arrays)
{
System.out.print(s+"\t");
}
String str5="   hello word  ";
System.out.println(str5.trim());

//          startsWith("参数")，判断字符串是否以参数值作为开头。
System.out.println(str4.startsWith("What"));
//endsWith("参数")，判断字符串是否以参数值作为结尾。
System.out.println(str4.endsWith("words"));
//substring()对字符串进行截取，第一个从下标2到最后，第二个从2到下标4-1.
String str6=str4.substring(2);
String str7=str4.substring(2, 4);
System.out.println(str6);
System.out.println(str7);

System.out.println(str4.replace("a", "b"));

}

    最终输出结果

    b
3
What	are	words	hello word
true
true
at:are:words
at
Whbt:bre:words
这里不做解释，请自行对照

    15.字符串的拼接

    这里介绍String拼接的几种方式，以及StringBuffer、StringBuilder，拼接的方式以及三种类型的差异区别。
    String,StringBuffer,StringBuider:

    • String：String是不可变长量，一点定义赋值后不能改变常量池或堆中的内容，这样会产生大量不可用字符。使用“+”或者String类中的concat()方法进行拼接。是一种引用类型，可以声明对象。
    • StringBuffer:可变长度的字符串，在进行字符串拼接后始终是一个对象，StringBuffer中的方法都是用synchronized进行修饰的表示线程安全的。
    • StringBuider是线程不安全对象，线程不安全但效率相对高一些。
      线程安全对象：用synchronized进行修饰的方法或代码块。一次只允许一个线程进行访问。线程安全，但效率低。
      线程不安全对象：没有使用synchronized进行修饰，线程不安全，效率高。
      下面给出演示代码：
    public static void main(String[] args) {
// TODO Auto-generated method stub
String str9="java";
String str10="bean";
System.out.println(str9.toString());
//直接使用“+”号链接即可
String str11=str9+str10;
System.out.println(str11);
String str12="javabean";
//此处经过测试知道字符串通过“+”号拼接相当于new String("javabean");一个对象
System.out.println(str11==str12);
//concat():拼接字符串，该方法与“+”号一样会创建一个新的字符串指向堆中,,并非字符串常量池中
String str13=str9.concat(str10);
System.out.println(str12==str13);
//StringBuffer:在进行字符串拼接后始终是同一个对象,
StringBuffer sb = new StringBuffer("Hello");
StringBuffer sb1=sb;

sb.append(" world");
//toString()函数输出字符串的内容
System.out.println(sb.toString());
System.out.println(sb);
System.out.println(sb1.toString());
System.out.println(sb==sb1);

//StringBuider可变长度的字符串，在进行字符串拼接后始终是一个对象，
StringBuilder sbu=new StringBuilder("tomcat");
sbu.append("good");
System.out.println(sbu.toString());
System.out.println(sbu);
}
输出结果：
java
javabean
false
false
Hello world
Hello world
Hello world
true
tomcatgood
tomcatgood

    16.comepareTo()和compareTolgnoreCase()//比较字符

    compareTo:按照字典顺序比较两个字符串
    str.comparTo(str1)
    比较规则：1.先按照字符序列进行逐位比较，只返回第一次出现的不同字符的差值。
    如果差值为正整数，表示str1在前，str在后。
    2.如果两个字符串长度不同，先按照第一比较规则进行，如果第一次比较规则比完仍然没有不同的字符，则直接 返回字符串的长度差值，如果差值为正数说明长的在前，短的在后。

    public static void main(String[] args) {
String str="helloa";
String str1="helL";
System.out.println(str.compareTo(str1));
System.out.println(str.compareToIgnoreCase(str1));
}

    17.indexOf()和lastindexOf

    • indexOf(ch)：返回字符以及子字符串第一次出现的下标，若没有的话会返回“-1”，找第二或者第三个只需嵌套使用即可。
    • lastindexOf(ch)：返回字符以及子字符串最后一次出现的下标，若没有的话会返回“-1”，找第二或者第三个只需嵌套使用即可。
    • indexof(int)int指对应字符的ASCII码

    18.toLowerCase(),toUpperCase(),转换为小写，转换为大写（）

    public static void main(String[] args) {
String str5="   Hello Word  ";
String str6=str.toLowerCase();
String str7=str.toUpperCase();
}
注意：汉字无法转接大小字符，会

    19.Valueof（基本数据类型）

    可以将基本数据类型转换为字符串

    System.out.println( String.valueOf(1234));

    20.getBytes()//将字符存储在字节数组中

    byte[] by= str8.getBytes();//转化为对应的ASCII码值，汉子也可以转化，只不过会输出负数，表示溢出。

    21.toCharArray()//将字符串转换为char类型的数组

    char[] array = str8.toCharArray();

    （三）包装类

    （1）包装类的概念

    概念：封装对应基本数据类型的属性以及相关操作方法。
    作业：让java更好的面向对象。
    基本数据类型包装类例子：

    //获得一个基本数据类型的字节数，位数，最大值，最小值。
println(Byte.BYTES+"\t"+Byte.SIZE+"\t"+Byte.MAX_VALUE+"\t"+Byte.MIN_VALUE);

    （2）包装类与String类以及基本数据类型之间的相互转换

    1.字符串与基本数据类型之间的转换

    基本数据类型转字符串：
    1.通过字符串拼接基本数据类型：String str=" "+10086;
    2.使用String类中的valueOf()方法，String str=String.valueOf(10086);
    3.将基本数据类型转换为封装类对象，通过封装类对象.toString();(效率低，不推荐)

    Integer inte=i;
String str = inte.toString();

    字符串转基本数据类型：
    1.通过基本对应数据类型封装类.parseXXX();

    int i= Integer.parseInte(str);

    2.通过封装类，先将字符串转为封装类对象。然后通过拆箱操作或者XXXValue();

    String str="123";

//Integer inte =new Integer(str)//将字符串转为封装类
// int i = inte;//这一步自动的
int i=Integer.valueOf(str);//这一步等价上面自动拆箱了
int i=Integer.valueOf(str).intValue();

    2.基本数据类型和封装类

    封装类转基本数据类型😭 效果一样
    1.自动拆箱

    Integer inte =new Integer(123);
int i = inte; //自动拆箱

    2.封装类对象.XXXvalue()

    Integer inte =new Integer(123);
int i = inte.intvalue();

    基本数据类型转封装类😭
    1.自动装箱

    Integer inte1=100;//这一步的100是在哪里算不算装箱
//int i=100;
//Integer inte1=i;

    2.通过封装类.valueOf(基本数据类型)

    Integer inte=Integer.valueOf(基本数据类型);

    3.通过封装类的构造方法

    Integer inte=new Integer(123);

    3.字符串和封装类

    封装类转字符串
    通过封装对象.toString();

    Integer inte=new Integer("123"或123)//;
String str=inte.toString();

    字符串转封装类😭
    通过封装类.valueOf(字符串参数);

    String str="123";
Integer inte = Integer.valueOf(str);
//这个是字符串转封装类吗，???
String str="123";
Integer inte=new Integer(str);//构造方法

    简单的小测试。

    		Integer inte=new Integer(123);Integer inte10=123;
Integer inte1=new Integer(123);
Integer inte2=123;
System.out.println(inte == inte1);
System.out.println(inte == inte2);
System.out.println(inte10 == inte2);
输出结果：
false
false
true
123
    内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息
    标签： 
    相关文章推荐
    新的分享
    章节导航