package day_13text;
public class Text01 {
}
class Student{
private int id;
private String name;
@Override
public boolean equals(Object obj) {
//需求:规定ID和name都相同 就是同一个人
//先比较地址,地址一样说明是同一个对象直接返回true
if(this == obj){
return true;
}
//说明不是同一个对象,那么需要判断是否是同类,不同类没有可比性
if(obj instanceof Student){
//向下转型,否则会丢失子类特有的属性(多态的缺点)
Student s = (Student)obj;
//String中覆写了equals方法,比较的是值
if(this.id == s.id && this.name.equals(s.name)){
return true;
}
}
//到这里说明不是同类对象,没有可比性,或者属性不一致直接返回false
return false;
}
}
package day_13text;
public class Text02 {
public static void main(String[] args) {
String s1 = new String("abc");
String s2 = new String("abc");
//比较的是s1 s2的地址
System.out.println(s1 == s2);
//比价的是字符串内容
System.out.println(s1.equals(s2));
}
}
1.3Finalize
package day_13text;
public class Text03 {
public static void main(String[] args) {
Text03 t =new Text03();
t=null;
//程序员可以建议垃圾回收器回收
System.gc();
for(int i =0;i<10000000;i++){
new Text03();
}
}
@Override
protected void finalize() throws Throwable {
System.out.println(this+":要被回收了");
}
}
1.4hashCode
package day_13text;
public class Text04 {
public static void main(String[] args) {
Text04 t = new Text04();
// 15db9742
System.out.println(t);
// 366712642
System.out.println(t.hashCode());
// 15db9742 toHexString : 转换为16进制显示,是Integer类中的静态方法
System.out.println(Integer.toHexString(366712642));
}
}
1.5toString
package day_13text;
public class Text05 {
public static void main(String[] args) {
Person person1 = new Person(1, "张三", 18);
Person person2 = new Person(2, "李四", 19);
System.out.println(person1);
System.out.println(person2);
}
}
class Person {
private int id;
private String name;
private int age;
@Override
public String toString() {
return "我叫" + this.getName() + ",我的编号是" + this.getId() + ",我今年"+ this.getAge() + "岁了";
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Person(int id, String name, int age) {
super();
this.id = id;
this.name = name;
this.age = age;
}
}
2.类与类之间的关系简述
类与类单继承
接口与接口多继承
类与接口多实现
package day_13text;
public class Text06 {
public static void main(String[] args) {
// 依赖
A a = new A();
B b = new B();
a.setB(b);
a = null;
// xxxxx
C c = new C();
c.setB(b);
}
}
class A {
// 关联
private B b;
public B getB() {
return b;
}
public void setB(B b) {
this.b = b;
}
}
class C {
private B b;
public B getB() {
return b;
}
public void setB(B b) {
this.b = b;
}
}
//多继承
interface E extends F, R {
}
interface F {
}
interface R {
}
//多实现
class B extends C implements E, F {
}
3.内部类
3.1是什么
3.2成员内部类
package day_13text;
public class Text07 {
private static String s1 = "私有化静态";
private String s2 = "私有化成员";
// 成员内部类,没有static修饰
// 可以使用权限控制修饰符的
// 成员内部类中可以 直接 访问外部类的所有属性
// 在成员内部类中不能有静态声明
// 内部类编译之后的类名为 : 外部类类名$内部类类名
class InnerClass {
// static int a = 1;
// public static void m1(){}
public void m2(){
System.out.println(s1);
System.out.println(s2);
}
}
public static void main(String[] args) {
// 外部类对象
Text07 outerClass_01 = new Text07();
// 通过外部类对象创建内部类对象
InnerClass innerClass = outerClass_01.new InnerClass();
innerClass.m2();
}
}
3.3静态内部类
package day_13text;
public class Text08 {
private static String s1 = "私有化静态";
private String s2 = "私有化成员";
// 静态内部类,使用static修饰
// 可以使用权限控制修饰符的
// 内部类编译之后的类名为 : 外部类类名$内部类类名
// 在静态内部类中 成员也能声明 静态也能声明
// 在静态内部类中,无法直接访问外部类的成员属性,需要有对象才行
static class InnerClass {
public void m1() {
System.out.println(s1);
// System.out.println(s2);
// 创建外部类对象才能调用 外部类的成员属性
Text08 o = new Text08();
System.out.println(o.s2);
}
public static void m2() {
System.out.println(s1);
// System.out.println(s2);
// 创建外部类对象才能调用 外部类的成员属性
Text08 o = new Text08();
System.out.println(o.s2);
}
}
public static void main(String[] args) {
Text08.InnerClass.m2();
// 外部类类名可以省略
InnerClass.m2();
// 创建对象
InnerClass innerClass = new Text08.InnerClass();
// 外部类类名可以省略
innerClass = new InnerClass();
innerClass.m1();
}
}
3.4局部内部类
package day_13text;
public class Text09 {
private static String s1 = "私有化静态";
private String s2 = "私有化成员";
public void m1() {
final int i = 100;
class InnerClass {
// static int x=2;
public void m3() {
System.out.println(s1);
System.out.println(s2);
System.out.println(i);
}
}
// 不能在更改
// i=2;
// 局部内部类只能在方法内部使用
// 创建内部类对象
InnerClass innerClass = new InnerClass();
innerClass.m3();
}
public static void m2() {
final int i = 100;
class InnerClass {
public void m3() {
System.out.println(s1);
// 静态方法中的内部类,不能直接访问外部类的成员属性,需要创建外部类对象才行
// System.out.println(s2);
System.out.println(i);
}
}
// 不能在更改
// i=2;
// 局部内部类只能在方法内部使用
// 创建内部类对象
InnerClass innerClass = new InnerClass();
innerClass.m3();
}
public static void main(String[] args) {
Text09 outerClass_03 = new Text09();
outerClass_03.m1();
m2();
}
}
