Java基础总结----第三章字符串、包装类、继承、多态

字符串：

（*）
 * 面试题
 * 写出十个位于Java。lang包下的类
 * String StringBuffer System Object 八种数据类型的包装类
 */

string位于Java。lang包下，在这个包下的类使用的时候不需要导包

//String创建对象有两种写法
//一种是引用字符串常量给字符串变量赋值
String s1="hello";
//一种是通过构造方法创建对象
String s2= new String();
char[] c={'h','e','l','l','o'};
String s3=new String(c);//将字符串的内容凭借起来做字符串
//使用字符数组中，索引为2的字符开始，长度为2的两个字符组成字符串作为内容
String s4= new String(c,2,2);
String s5= new String("hello");

（*）
 * 面试题
 * 为什么String打印输出的是内容，而普通引用类型的对象输出的是地址呢
 * 因为String重写了object的tostring方法，所以在调用输出的时候，会将字符串转换成数组字符。再将
 * 字符数组输出到控制台上，所以输出的是字符串的内容，而普通引用变量调用的是object的tostring方法
 * 打印输出的是完整的类路径+类名+@+十六进制地址值
 */

* 问下面语句创建了几个对象
 * 答：字符串常量位于字符串常量池中，而字符串常量池在1.6 之前位于方法区中，在1.8之后
 * 为于堆区中，而字符串常量池在设计的时候，为了减少内存，当字符串常量池中需要使用的字符串常量
 * 已经存在的时候会直接调用这个常量，而常量池中没有这个字符串常量才会创建一个新的字符串，但是不管常量池中如何
 * 只要有new 就会在堆区中产生一个对象所以产生多少个对象，要考虑堆区和常量池中
 */
String s1="hello";//1
String s2=new String();//1
String s3=new String("hel1o");//2
String s4=new String("hello world");//2
String s5="hello World";//1
String s6="hello world";//0
String s7="q"+"w"+"e"+"r"+"d"+"f";//编译器优化完为 String s7="qwerdf"
String s8="a"+"b"+"c"+"d"+"e"+"f";//编译器优化完为 String s7="abcdef"

下面是一些处理字符串的常用处理的方法：

String s=" hello world ";
//获取字符串的长度
System.out.println(s.length());
// 查找字符串的方法，查到了返回字符串第一个字符串的索引，查不到返回-1
//字符串索引也是从0开始的 不管正向还是反向，索引都是从左侧开始的
System.out.println(s.indexOf("ll"));//从左到右查找
System.out.println(s.lastIndexOf("ll"));//从右到左反向查找
//获取索引位置的字符
System.out.println(s.charAt(2));
//截取字符串，从源字符串中截取一个新的字符串
System.out.println(s.substring(2,7));
//去除字符串的前后空格
System.out.println(s.trim());
//替换字符串
System.out.println(s.replace(" ",""));

（*）
 * 面试题
 * equals方法的实现原理
 * String的equals比较的是两个字符串的内容是否相同，所以会将字符串转换为字符数组进行按位逐一
 * 比较但是为了提高比较效率，equals 会进行三重判断，第一重比较两个对象的地址是否相同
 * 如果相同则认为同一个对象，会直接返回true 否则进行第二重判断，第二重判断比较对象是不是String类型的对象
 * 如果不是则直接返回false；如果是则进行第三重判断，第三重判断比较两个字符串长度是否相同，不同返回false
 * 如果相同则转换成字符数组进行注意比较
 *
 * 注意不是字符串类型的对象使用equals 那么，equals比较就等于==
 */

//Stringbuffer字符串缓冲区，也是字符串生成器
StringBuffer sb1=new StringBuffer();//默认长度为16的字符数组
StringBuffer sb2=new StringBuffer(20);
StringBuffer sb3=new StringBuffer("hello");
//String buffer 不能通过+或者+=来拼接字符串
sb3.append("world");
System.out.println(sb3);
System.out.println(sb3.toString());
System.out.println("hello".toString());

（*）

（StringBuffer是线程安全的，StringBuilder线程是不安全的，但是性能StringBuffer比StringBulider差一点。。）

//Stringbuffer字符串缓冲区，也是字符串生成器
StringBuffer sb1=new StringBuffer();//默认长度为16的字符数组
StringBuffer sb2=new StringBuffer(20);
StringBuffer sb3=new StringBuffer("hello");
//String buffer 不能通过+或者+=来拼接字符串
sb3.append("world");
System.out.println(sb3);
System.out.println(sb3.toString());
System.out.println("hello".toString());

包装类：

int a=10;
//用基本数据类型直接给包装类赋值，就是自动装箱
Integer i1=a;
//包装类还是引用类型的的变量还是可以通过构造方法创建对象的
Integer i2= new Integer(20);
//用包装类类型的对象给基本数据类型赋值就是自动拆箱
int b=i2;
//注意自动装箱和自动拆箱只有jdk1.5之后才可以使用
//将包装类转换为String类型
String s=i1.toString();
//将字符串转换为基本数据类型
int c= Integer.parseInt(s);
double d=Double.parseDouble(s);

继承：

//继承子类会自动拥有父类的说有成员
//extends关键字表示继承关系，左侧为子类，右侧为父类
//子类又称为派生类，父类又称为基类超类

public class Student extends Person{}

//方法重写，当父类方法不能满足之类的需要时候进行方法重写
//1.要有继承关系，同时在子类中进行方法重写
//2.方法名要完全一致
//3.参数的个数，类型，顺序要完全一致
//4.返回值类型相同或者协变（协变返回值类型就是父类的方法返回父类的对象，子类的方法返回之类的）
//注意：重写方法不能缩小父类的访问范围

//用private修饰的成员不能被继承

final关键字：

//final不能修饰构造方法
//public final FinalTest(){}
//final可以修饰方法
//final可以修饰方法，修饰的方法，可以被继承，但不能被重写

//final可以修饰类，final修饰的类不能被继承，没有子类，但可以有父类

多态：

多态：同样的消息被不同的对象接受产生的不同行为
条件：要有继承，要有重写，要有向上转型

public class Student extends Person {
    public static void main(String[] args) {
        //对象类型之间也存在类型转换，被称为对象转型
        //注意：对象转型只发生在父类和子类类型之间，所以无继承，就没有对象转换
        //对象转型有两种，一种是向上转型，一种为向下转型
        //向上转型：子类对象给父类的引用变量赋值，自动转换
        //向上转型的实质就是子类中小的那个父类对象，给父类类型赋值，所以是小的数据类型转换为大
        // 的数据类型，因此是自动转换
        //向上转型的两种写法
        Person p1=new Person();
        Student s1=new Student();
        p1=s1;
        Person p2=new Student();
        //向下转型：父类给子类的引用变量赋值，强制转换
        //要想使向下转型正常使用，必须要保证父类对象要在子类对象之中，而能保证父类对象在子类对象
        // 之中只能是向上转型，所以在使用向下转型前需要先进性向上转型，否则编译报错
        Person p3=new Student();
        Student s3=new Student();
        s3=(Student)p3;
    }
}

class Person{}

instanceof关键字：

Person p=new Person();
Student s=new Student();
//instanceof计算的是当前对象是不是有该类型或者该类型的父类创建的对象
System.out.println(p instanceof Person);
System.out.println(s instanceof Person);
System.out.println(p instanceof Student);//false
System.out.println(s instanceof Student);