JavaBasic_11

Object默认的实现是比较对象的地址

Object默认的实现是比较对象的地址局部内部类

---

局部位置内部类：局部是指方法体中

1.可以直接访问外部类的成员（这个特征是所有内部类所共有）

2.可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能

局部内部类，只能在方法体中使用

对于普通类而言，类定义的先后顺序不会影响我们的代码

对于局部内部类，必须先定义再使用

局部内部类访问局部变量的注意事项：

1.被final修饰？是

2.为什么呢？

1.因为局部变量会随着方法的调用完毕而消失

2.这个时候，局部变量并没有立马从堆内存中消失，还要使用那个变量

（对象的引用变量，还可以被其他的对象使用，这就意味着，该局部内部类对象的成员方法，仍可以被调用。）

3.为了让数据还能继续被使用，就用final修饰

4.这样，在堆内存里面存储的其实是一个常量值。通过反编译工具可以看一下

public class InnerClassDemo2 {

    public static void main(String[] args) {

        TestLocalInnerClass testLocalInnerClass = new TestLocalInnerClass();
        testLocalInnerClass.show();
    }

}

class TestLocalInnerClass {

    public void show() {

        //局部变量，注意，此处我们即使没有给局部变量加final修饰符，
        // 在局部内部类中仍然可以正常访问，是因为，编译器，在字节码文件中帮我们添加了final修饰符
        final int j = 100;

        //局部位置内部类,必须先定义在使用
        class LocalInner {

            int i = 10;

            public void test() {
                // 访问局部内部类成员变量
                //System.out.println(i);

                //访问定义局部内部类的方法体中，所定义的局部变量
                System.out.println(j);
            }
        }

        //只能在方法体中，使用局部内部类创建对象
        LocalInner localInner = new LocalInner();
        localInner.test();

    }
}

//LocalInnerClass
//Local局部   Inner内部 Class类

public class WhyLocalInnerClass {
    Inter a;

    public void setA(Inter a) {
        this.a = a;
    }

    public static void main(String[] args) {

        WhyLocalInnerClass w = new WhyLocalInnerClass();

        Outer1 outer1 = new Outer1();

        outer1.testLocal(w);

        w.a.accLocalInLocal(null);
    }
}

abstract class Inter {
    public abstract void accLocalInLocal(Inter inter);
}

class Outer1 {

    public void  testLocal(WhyLocalInnerClass w) {

        int  j = 100;
        class LocalInner extends Inter{

            @Override
            public void accLocalInLocal(Inter inter) {
                System.out.println(j);
            }
        }
        LocalInner l = new LocalInner();
        w.setA(l);
    }

}

interface  TestObject {

    default void testObject() {
        toString();
        getClass();
    }
}

匿名内部类

匿名内部类：就是内部类的简化写法

前提：存在一个类或接口（这里的类可以使具体类也可以是抽象类）

格式：new 类名 或者 接口名(){重写方法;}

本质：是(一个继承了类（一般是抽象类））或者（实现了接口的子类)匿名对象

public class InnerClassDemo3 {

    public static void main(String[] args) {
        //没有引用变量指向该对象，也就是说该对象没有名字，我们称这种对象为匿名对象
        new InnerClassDemo3();

        //new 类名或者接口名() {重写方法;}
        // 匿名内部类的类型？ 该匿名类的类型是其父类类型(接口，或者抽象类的类型，即父类型)
        new AnanymousAbClass() {

            @Override
            public void myMotify() {

            }

            @Override
            public void myOberve() {

            }
        };

        //访问匿名内部类的成员？

        //第一种访问方式
        //成员变量
        System.out.println(
                new AnanymousAbClass() {

                    @Override
                    public void myMotify() {

                    }

                    @Override
                    public void myOberve() {

                    }

                }.i
        );

        //成员方法
        new AnanymousAbClass() {

            @Override
            public void myMotify() {

            }

            @Override
            public void myOberve() {

            }

        }.myMotify();

        new AnanymousAbClass() {

            @Override
            public void myMotify() {

            }

            @Override
            public void myOberve() {

            }

            public void test() {

            }

        }.test();

        //第二种调用方式
        //用类或者接口接收该子类对象，多态思想
        AnanymousAbClass a  = new AnanymousAbClass() {

            @Override
            public void myMotify() {

            }

            @Override
            public void myOberve() {

            }

            public void test() {

            }

        };

        a.myOberve();
        a.myMotify();
    }
}

abstract class  AnanymousAbClass {
    int i = 100;
   public abstract   void myMotify();

   public abstract void myOberve();
}

//匿名内部类面试题
//按照要求，补齐代码

interface Inter { void show(); }
 class Outer12 {
     static Inters method(){
         return new Inters(){

            @override
             public void show(){
                 sout("helloworld")
             }
         }
     }
 }//补齐代码
    public class OuterDemo {
        public static void main(String[] args) {
              (Outer12.method()).show(); //Outer.method()可以看出是静态
          }
    }
要求在控制台输出”HelloWorld”
    -------------------

Object类

---

Object类概述

Object类是所有Java类的根父类

类层次结构的根类,所有类都直接或者间接的继承自该类

构造方法

public Object()

API一般指的是方法

所有类的共同点：

constuctor 构造方法

field 成员变量

method 成员方法

1.public final Class getClass() 字节码文件对象 返回运行时类

---

1.Class类的实例(表示正在运行的Java应用程序中的)类和接口

2.jvm在加载的时候

    a.首先将字节码文件内容加载到方法区中

    b.将字节码的二进制内容，转化成相应时运行时数据结构(oracle java虚拟机规范，并未规定具体的字节码文件内容的运行时数据结构)

    c.在堆中，给这个字节码文件的运行时数据结构，创建字节码文件对象

每一个字节文件，都对应一个字节码文件对象

//获取全类名
sout(objectdemo1.getClass().getName());
//获取简单类名
sout(objectDemo2.getClass().getSimleName)

2.public int hashCode() hash码 散列码

---

如何实现将一个对象对应到一个数值呢？这一般是通过将该对象的内部地址转换成一个整数来实现的

常规协定：

1.在 Java 应用程序执行期间，在对同一对象多次调用 hashCode 方法时，必须一致地返回相同的整数，

前提是将对象进行 equals 比较时所用的信息没有被修改（一旦修改了成员变量的值）。

提醒我们，根据对象的内容生成hashcode

2.如果根据 equals(Object) 方法，两个对象是相等的，那么对这两个对象中的每个对象调用hashCode 方法都必须生成相同的整数结果。

3.如果根据 equals(java.lang.Object) 方法，两个对象不相等，那么对这两个对象中的任一对象上调用 hashCode 方法不 要求一定生成不同的整数结果

从某一应用程序的一次执行到同一应用程序的另一次执行，该整数无需保持一致。

3.public boolean equals(Object obj)

---

指示其他某个对象是否与此对象"相等"

Object默认的实现是比较对象的地址

equals方法的常规规定：1.自反 2.对称 3.传递 4.一致性

1.对于任何非空引用值x和y多次调用x.equals(y)始终返回true或始终返回

2.前提是对象上 equals 比较中所用的信息(指对象所有成员变量的值)没有被修改。

4.public String toString

---

返回该对象的字符串表示。通常，toString方法会返回一个“以文本方式表示”此对象的字符串。（以文本的方式描述该对象）

返回的是一个字符串，字符串有一个特殊的作用：以文本的方式描述该对象

5.protected void finalize() 在垃圾回收器回收对象空间之前

---

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

native方法非java语言实现，free()

不推荐使用finalize方法，因为垃圾回收器的执行时间不确定。

system.gc(); //强制启动垃圾回收器

6.protcected Object clone() object默认实现的clone浅拷贝

---

//object默认实现的clone方法是浅拷贝

clone顾名思义就是复制， 在Java语言中， clone方法被对象调用，所以会复制对象。所谓的复制对象，首先要分配一个和源对象同样大小的空间，在这个空间中创建一个新的对象。

public class ObjectDemo1 implements Cloneable{

    int i = 10;
    double j = 100;
    InnerObject obj = new InnerObject(100);

    public static void main(String[] args) throws CloneNotSupportedException {
        //Class<ObjectDemo1> objectDemo1Class = ObjectDemo1.class;
        ObjectDemo1 objectDemo1 = new ObjectDemo1();

        //getClass获取的是实际运行的类的字节码文件对象，获取全类名
        //System.out.println(objectDemo1.getClass().getName());

        //获取该字节码文件对象的简单类名
                     //System.out.println(objectDemo1.getClass().getSimpleName());

        // public int hashCode()
        int hash = objectDemo1.hashCode();
        //System.out.println("hashCode = " + hash);

        //public boolean equals(Object obj)
        ObjectDemo1 objectDemo11 = new ObjectDemo1();
        ObjectDemo1 objectDemo12 = new ObjectDemo1();

        // objectDemo13 和 objectDemo11 指向了同一个对象
        ObjectDemo1 objectDemo13 = objectDemo11;

        //System.out.println(objectDemo11.equals(objectDemo12));//虽然两个对象包含的内容相同，
                                                              // 但是这两个引用指向了两个不同的对象
     //  false

        //System.out.println(objectDemo11.equals(objectDemo13)); //两个引用变量指向同一个对象  true

        //toString方法  getClass().getName() + '@' + Integer.toHexString(hashCode())
       // System.out.println(objectDemo1.toString());

        new ObjectDemo1();

        //强制启动垃圾回收器
        System.gc();

        //clone 创建并返回此对象的一个副本。
        ObjectDemo1 objectDemo14 = new ObjectDemo1();
        System.out.println(objectDemo14.hashCode());
        Object clone = objectDemo14.clone();
        System.out.println(clone.hashCode());
        System.out.println(clone);

        ObjectDemo1 objectDemo15 = new ObjectDemo1();
        Object clone1 = objectDemo15.clone();

        //修改复制之后的成员变量的值
        ObjectDemo1 clonea = (ObjectDemo1) clone1;

        clonea.obj.i = 300;

        System.out.println(objectDemo15.obj.i);

    }

    @Override
    protected  void finalize() {
        System.out.println("我要被回收了");
    }

    @Override
    public String toString() {
        return "ObjectDemo1{" +
                "i=" + i +
                ", j=" + j +
                '}';
    }

}

class InnerObject {

    int i = 100;

    public InnerObject(int i) {
        this.i = i;
    }

}

String类

---

String类概述

字符串是由多个字符组成的一串数据(字符序列)

字符串可以看成是字符数组

字符串最大的特征： 一旦创建就不能修改

==字符串是常量，它的值在（创建之后不能更改）拼接的时候，总是创建新的空间来连接字符串，而不会修改原字符==

public class StringDemo2 {

    public static void main(String[] args) {
        //String s = “hello”; s += “world”; 问s的结果是多少?
        String s = "hello";
        s += "world";
        System.out.println(s);

        //String s = new String("hello")和String s = “hello”;的区别?
        String s1 = new String("hello");
        s1 +=  "java";
        String s2 = "hello";
    }
}

构造方法

public String()

public String(byte[] bytes)

public String(byte[] bytes,int offset, int length)

public String(char[] value )

public String(char[] value, int offset, int count)

public String(String original)

String类的判断功能

---

• boolean equals(Object obj)
• boolean equalsIgnoreCase(String str)
• boolean contains(String str)
• boolean startsWith(Strign str)
• boolean endWith(String str)
• boolean isEmpty()

String类的获取功能

---

• int length()
• char charAt(int index)
• int indexOf(int ch)
• 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)

String类的转换功能

---

byte[] getBytes()

char[] toCharArray()

static String valueOf(char[] chs)

static String valuesOf(int i)

String toLowerCase()

String toUpperCase()

String concat(String str)

String类的其他功能

---

替换功能

String replace(char old, char new)

String replace(String old, String new)

去除字符串两空格

String trim()

按字典顺序比较两个字符串

int compareTo(String str)

int compareToIngoreCase(String str)