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)