Java学习第八天

1、多态中成员的特点：
　　1:成员变量: 编译时期看父类，运行结果看父类
　　2：成员方法: 编译时期看父类,运行结果看子类（子类把方法重写了）
　　3：静态方法: 编译时期看父类,运行结果看父类

2.Object：根类，超类，对所有对象共性的提取,所有
　　　　任何类，如果没有书写extends显示继承某个类，都默认直接继承Object类
　　　　Object类中所定义的方法，是所有对象都具备的方法（11个方法，可以自己查一下api吧）
　　特点：
　　Object类型可以存储任何对象：
　　作为参数，可以接受任何对象
　　作为返回值，可以返回任何对象
　　例如：
　　boolean equals(Object obj);

3.当输出一个对象时，默认调用了 toString()方法，默认toString()方法返回：类名@对象的哈希值

1.默认实现
int hash=ren1.hashCode();
System.out.println(Integer.toHexString(hash));

//得到对象对应的字节码
Class classz=ren1.getClass();//Person.class 被面向对象了 Class
String name = classz.getName();
System.out.println(name);
//最后结合输出
System.out.println(ren1.getClass().getName()+"@"+Integer.toHexString(ren1.hashCode()));

2.通常重写toString()，返回属性的值
public String toString(){
　　return name+","+age;
}

 

 4.模板设计模式：在实现一个功能时，功能的一部分是确定的，一部分是不确定的，确定的部分会用到不确定的部分

　　　　　　那么就把不确定的部分暴露出去，让子类去实现

例如：计算程序运行的时间
abstract class TimeTool
{
    public final void tongJiTime()
    {
        //在程序运行前记录一个时间
        long start=System.currentTimeMillis();

        //功能代码
        fun();

         //在程序运行后记录一个时间
         long end=System.currentTimeMillis();
         System.out.println("程序运行时间为:"+(end-start)+"毫秒");
    }
    public abstract void fun();
}

class Test extends TimeTool
{
    public void fun(){
        for(int i=1;i<=3000;i++)
        {
            System.out.println(i);
        }
    }
}
class Demo4 
{
    public static void main(String[] args) 
    {
        Test test = new Test();
         test.tongJiTime();
    }
}    

 5.内部类：在一个类的内部定义的类就叫内部类(把内部类看成成员),成员和成员之间可以相互使用

内部类的特点：
1.编译后可生成独立的字节码文件
2.内部类可直接访问外部类的私有成员，为不破坏封装
3.可为外部类提供必要的内部功能组件

 

6.内部类的字节码:外部类$内部类.class

7.什么时候需要定义内部类？需要描述事物内部的事物

 

8.成员内部类：在类的内部定义，与实例变量、实例方法同级别的类
　　　　　　　外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象
　
　　　特点：当外部类、内部类存在重名属性时，会优先访问内部类属性
　　　　　　成员内部类不能定义静态成员

class Outer{

class Inner{

}
}

class Outer{

static class Inner{
public static void show(){}
}
}

Outer out=new Outer();
Inner in=out.new Inner();

　　　　内部类访问外部类对象: 外部类名.this

 　　　  内部类访问外部类对象中的成员，外部类名.this.成员名

9.静态内部类:内部类属于成员，所以可以被static修饰，内部类中的方法是静态的，那么内部类必须是静态的
　　　　　　不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员

　　　　　　只能直接访问外部类的静态成员（实例成员需实例化外部类对象）
　　　　　　Outer.Inner inner=new Outer.Inner();
　　　　　　Outer.Inner.show();

10.局部内部类：定义在外部类的方法中，作用范围和创建对象范围仅限于当前方法
　　　　　　　局部内部类访问外部类当前方法中的局部变量时，因为无法保障变量的生命周期与自身相同，变量必须修饰为final
　　　　　　　限制类的使用范围(jdk1.8开始，局部内部类使用的局部变量不需要使用final 修饰)

11.匿名内部类：没有类名的局部内部类（一切特征都与局部内部类相同）
　　　　　　特点：必须继承一个父类或者实现一个接口
　　　　　　　　　定义类、实现类、创建对象的语法合并，只能创建一个该类的对象

　　　　　　　　　优点：减少代码量
　　　　　　　　　缺点：可读性较差

适用于类和接口： new Object(){
String name;
public void show(){
}
}.show();

Object obj= new Object(){
String name;
public void show(){
}
};


new inter(){
public void show(){
}
}.show();


inter tt=new inter(){
public void show(){
}
};

 

12.字符串: class final String extends Object

是常量，一旦定义了就不可以改变了
存储在方法区的常量池
已经存在的字符串，再定义时直接使用已经存在的
重写了equals()方法
String s=new String("hello");//产生两个对象，堆、池中各存储一个

　　charAt(6)
　　indexOf()
　　lastIndexOf()
　　contains()
　　equals()
　　equalsIgnoreCase()‘/
　　startsWith()
　　endsWith();


13.字符串获取：
　　获取字符串的长度
　　int length()
　　获取某一个位置上的字符
　　char charAt(int index)
　　获取字符在字符串中的位置
　　如果要找的字符或者字符串不存在，返回值为-1
　　int indexOf(char ch)//返回字符在字符串中第一次出现的位置
　　int indexOf(int ch, int fromIndex)//第二个参数用于指定开始找的位置

　　int indexOf(String str) //获取一个字符串在字符串中出现的位置
　　int indexOf(String str, int fromIndex)//第二个参数用于指定开始找的位置

　　int lastIndexOf(char ch)//最后一次出现的位置
14.字符串判断：
　　判断是否包含一个字符串
　　boolean contains(CharSequence s)
　　判断两个字符串的内容是否相同
　　boolean equals(Object anObject)
　　忽略大小写判断两个字符串的内容是否相同
　　boolean equalsIgnoreCase(String anotherString)
　　判断是否以某字符串开头
　　boolean startsWith(String prefix)
　　判断是否以某字符串结尾
　　boolean endsWith(String suffix)
15.字符串转换：将字符数组转换成字符串
　　1:使用构造方法
　　　String(char[] value)
　　　String(char[] value, int offset, int count)
　　2:使用静态方法
　　　static String copyValueOf(char[] data)
　　　static String copyValueOf(char[] data, int offset, int count)
　　　将字符串转成字符数组
　　　char[] toCharArray()

16.将字节数组转成字符串
　　　String(byte[] bytes)
　　　String(byte[] bytes, int offset, int length)
　　　String(byte[] bytes, String charsetName)//使用指定的编码将字节数组转换成字符成
　　　将字符串转成字节数组
　　　byte[] getBytes()

　　　将基本数据类型转换成字符串
　　　String.valueOf()
17.字符串替换：
　　　String replace(char oldChar, char newChar)

18.子串:
　　String substring(int beginIndex)
　　String substring(int beginIndex, int endIndex) //包含起始位置，不包含结束位置，到结束位置的前一位

19.转换，去除空格，比较:
　　大小写转换
　　String toLowerCase()
　　String toUpperCase()
　　将字符串两端的空格去掉
　　String trim()
　　按字典顺序比较两个字符串
　　int compareTo(String anotherString)
20.切割: String[] split(String)


21.可变字符串：
　　StringBuffer:可变长字符串，JDK1.0提供，运行效率慢、线程安全
　　StringBuilder:可变长字符串，JDK5.0提供，运行效率快、线程不安全

22.BigDecimal:可精确计算浮点数