11、内部类和Object类

部类和Object类"/>

11、内部类和Object类

DAY13 内部类和Object类

内部类

概述

内部类：定义在一个类内部的类叫做内部类语法：
class 外部类 ｛//成员位置实例变量静态变量实例方法静态方法//局部位置（局部变量的位置）方法｛int a = 10;//局部变量｝｝为什么会有内部类的结构？人类｛私有  嘴  泌尿系统器官类消化系统器官类｝

内部类的分类

成员内部类（实例成员）

位置：成员内部类的定义位置相当于类中的实例成员位置
定义语法：
class 外部类{//内部类class 内部类{}}对象创建的语法：（成员内部类的对象必须依赖外部类的对象才能创建）
外部类类名  外部类对象名 = new 外部类类名（）；
外部类类名.内部类类名  内部类对象名 = 外部类对象名.new 内部类类名（）；
eg://1 创建外部类的对象Outer outer = new Outer();//2 通过外部类对象创建内部类对象  Outer.Inner inner = outer.new Inner();特点：1.编译之后也会生成单独的字节码文件2.成员内部类可以访问外部类的私有成员，而不破坏封装3.当成员内部类中的属性和方法和外部类中的属性和方法存在重名的情况，用  类名.this.   区别4.成员内部类中不能定义静态成员（属性和方法）
案例1：
package cn.baizhi.day13;public class Demo1 {public static void main(String[] args) {//1 创建外部类的对象Outer outer = new Outer();//2 通过外部类对象创建内部类对象  Outer.Inner inner = outer.new Inner();}
}// 定义外部类
class Outer {// 属性private int a = 10;int b = 20;static int c = 30;// 私有的方法private void m2() {}// 静态方法public static void m3() {}// 定义成员内部类class Inner {// 属性int d = 40;int a = 50;// 方法public void m1() {System.out.println(a);// 访问外部类的私有成员变量m2();// 访问私有的成员方法System.out.println(c);m3();System.out.println(d);}}}案例2：关于重名的属性和方法区别
package cn.baizhi.day13;public class Demo1 {public static void main(String[] args) {//1 创建外部类的对象Outer outer = new Outer();//2 通过外部类对象创建内部类对象  Outer.Inner inner = outer.new Inner();inner.m1();}
}// 定义外部类
class Outer {// 属性private int a = 10;// 定义成员内部类class Inner {// 属性int a = 50;// 方法public void m1() {//int a = 100;/*System.out.println(a);// 访问外部类的私有成员变量  100System.out.println(Inner.this.a);//50System.out.println(Outer.this.a);//10*/		//Inner.this.m2();Outer.this.m2();}public void m2() {System.out.println("内部类的m2");}}public void m2() {System.out.println("外部类的m2");}}案例 3：关于成员内部类中是否能定义静态的成员
package cn.baizhi.day13;public class Demo1 {public static void main(String[] args) {//1 创建外部类的对象Outer outer = new Outer();//2 通过外部类对象创建内部类对象  Outer.Inner inner = outer.new Inner();}
}// 定义外部类
class Outer {// 定义成员内部类class Inner {//类变量//static int a = 20;//静态方法public static void m1() {}}}

静态内部类（静态成员）

位置：静态内部类和类中的静态成员地位相当
语法：
class 外部类{static class 静态内部类类名{}
}对象创建的语法：静态内部类的对象不需要通过外部类对象创建
eg://创建对象Outer.Inner inner = new Outer.Inner();特点：1.编译之后也会生成单独的class文件2.静态内部类只能直接访问外部类的静态成员（属性和方法），不能直接访问外部类的非静态成员，如果非要访问，必须通过创建对象访问3.当静态内部类和外部类静态成员重名，可以直接通过 类名. 解决案例1：关于静态内部类能够访问外部类的哪些成员
package cn.baizhi.day13;public class Demo1 {public static void main(String[] args) {//创建对象Outer.Inner inner = new Outer.Inner();}
}// 定义外部类
class Outer {//属性int a = 10;//实例变量static int b =20;//静态变量//实例方法public void m1() {System.out.println("外部类的实例方法m1");}//静态方法public static void m2() {System.out.println("外部类的静态方法m2");}//定义静态内部类static class Inner{public void m3() {//System.out.println(a);//m1();Outer outer = new Outer();System.out.println(outer.a);outer.m1();System.out.println(b);m2();}}
}案例2：关于静态成员重名问题
package cn.baizhi.day13;public class Demo1 {public static void main(String[] args) {//创建对象Outer.Inner inner = new Outer.Inner();inner.m3();}
}// 定义外部类
class Outer {//属性int a = 10;//实例变量static int b =20;//静态变量//实例方法public void m1() {System.out.println("外部类的实例方法m1");}//静态方法public static void m2() {System.out.println("外部类的静态方法m2");}//定义静态内部类static class Inner{//实例变量//int a = 30;static int b = 40;public void m3() {/*System.out.println(a);//m1();Outer outer = new Outer();System.out.println(outer.a);outer.m1();*//*System.out.println(Inner.b);System.out.println(Outer.b);*/Outer.m2();}public static void m2() {System.out.println("内部类的静态方法m2");}}
}

局部内部类（局部变量的位置）

位置：局部内部类定义在外部类的方法中 相当于局部变量的位置 见案例1
语法：
class 外部类{public void m(){class 内部类{}}
}特点：1.也可以生成独立的class文件2.局部内部类中不可以定义静态的成员3.在局部内部类中可以直接访问外部的成员（静态成员和实例成员）4.局部内部类中可以访问外部类的局部变量，但是必须要求外部类的局部变量是final修饰的 jdk8起 默认添加final案例1：关于局部内部类对象创建的方式
// 定义外部类
class Outer {public void m1() {// 定义一个局部内部类class Inner {}// 创建对象Inner inner = new Inner();}/** public static void m2() { class Inner {* * } }*/}案例：关于访问哪些成员
package cn.baizhi.day13;public class Demo1 {public static void main(String[] args) {}
}// 定义外部类
class Outer {//属性int a = 10;static int b =20;public void m3() {}public static void m4() {}public void m1() {// 定义一个局部内部类class Inner {//static int c = 30;//不能定义静态的属性int c = 30;//方法public void m2() {System.out.println(a);System.out.println(b);m3();m4();}/*public static void m3() {}*///不能定义静态方法}// 创建对象//Inner inner = new Inner();}/** public static void m2() { class Inner {* * } }*/}
案例：局部内部类访问外部类的局部变量
package cn.baizhi.day13;public class Demo1 {public static void main(String[] args) {Outer outer = new Outer();outer.m1();}
}// 定义外部类
class Outer {public void m1() {//定义一个外部类的局部变量final int a = 30;// 定义一个局部内部类class Inner {public void m2() {System.out.println(a);//a的照片}}//创建局部内部类的对象Inner inner = new Inner();inner.m2();}}练习：教学的接口 教学的方法学校类 方法：为学生提供老师教学的方法刘洋类  实现教学的接口
高健类  实现教学的接口
代码：
package cn.baizhi.day13;import java.util.Scanner;public class Demo2 {public static void main(String[] args) {//通过学校获取老师--正当途径Scanner scanner = new Scanner(System.in);System.out.println("请输入一个整数：");int i = scanner.nextInt();Teach teacher = School.getTeacher(i);teacher.teach();//开辅导班/*LiuYang liuYang = new LiuYang();liuYang.teach();*/}
}//定义一个接口
interface Teach{void teach();
}//定义一个学校类
class School {//定义一个方法public static Teach getTeacher(int i) {//定义高健class GaoJian implements Teach{@Overridepublic void teach() {System.out.println("高健教  抽烟 喝酒 大保健");}}//刘洋class LiuYang implements Teach{@Overridepublic void teach() {System.out.println("刘洋教java");}}//当i为奇数返回高健 反之 返回刘洋if (i%2==0) {return new LiuYang();} else {return new GaoJian();}}
}

匿名内部类（特殊的局部内部类）

匿名内部类：是一个特殊的局部内部类，当一个类实现了一个接口或者继承了一个类的时候可以写成匿名内部类的形式语法：看下边的案例特点：匿名内部类只能使用一次去创建对象案例：
package cn.baizhi.day13;import java.util.Scanner;public class Demo2 {public static void main(String[] args) {//通过学校获取老师--正当途径Scanner scanner = new Scanner(System.in);System.out.println("请输入一个整数：");int i = scanner.nextInt();Teach teacher = School.getTeacher(i);teacher.teach();//开辅导班/*LiuYang liuYang = new LiuYang();liuYang.teach();*/}
}//定义一个接口
interface Teach{void teach();
}//定义一个学校类
class School {//定义一个方法public static Teach getTeacher(int i) {//当i为奇数返回高健 反之 返回刘洋if (i%2==0) {return new Teach(){@Overridepublic void teach() {System.out.println("刘洋教java");}};} else {return new Teach() {@Overridepublic void teach() {System.out.println("抽烟   喝酒 烫头");}};}}
}案例：
package cn.baizhi.day13;import java.util.Scanner;public class Demo2 {public static void main(String[] args) {//通过学校获取老师--正当途径Scanner scanner = new Scanner(System.in);System.out.println("请输入一个整数：");int i = scanner.nextInt();Teach teacher = School.getTeacher(i);teacher.teach();//开辅导班/*LiuYang liuYang = new LiuYang();liuYang.teach();*/}
}//定义一个接口
interface Teach{void teach();
}//定义一个学校类
class School {//定义一个方法public static Teach getTeacher(int i) {//定义高健class GaoJian implements Teach{@Overridepublic void teach() {System.out.println("高健教  抽烟 喝酒 大保健");}}//刘洋class LiuYang implements Teach{@Overridepublic void teach() {System.out.println("刘洋教java");}}///*class (假装没有名字) implements Teach{@Overridepublic void teach() {System.out.println("刘洋教java");}}*///当i为奇数返回高健 反之 返回刘洋if (i%2==0) {return new Teach(){@Overridepublic void teach() {System.out.println("java");}};} else {return new GaoJian();}}
}

Object类

学习方法：要学会自己学习研究，API 要学会自己查到应用Object：是所有类的顶级父类   超类 基类  相当于人类的中类人猿   女娲   上帝类Object类型的引用可以指向任何类型的对象

protected void finalize()：当垃圾回收时会调用这个方法，标志着垃圾回收器回收垃圾垃圾：当一个对象没有任何的引用指向的时候，这个对象就成为垃圾Student student = new Student();student = null;
垃圾回收：Java中有自己的垃圾回收机制自动进行垃圾回收：当垃圾达到一定值的时候，垃圾回收机制会自动的回收垃圾
手动垃圾回收：可以通过代码通知垃圾回收器进行垃圾回收，但是垃圾回收器不一定进行垃圾回收，不一定管用案例：自动垃圾回收
package cn.baizhi.day13;public class Demo5 {public static void main(String[] args) {for (int i = 0; i < 10000000; i++) {new Student();}}
}class Student extends Object{public void finalize() throws Throwable { super.finalize();System.out.println("垃圾被回收了");}}案例：
package cn.baizhi.day13;public class Demo5 {public static void main(String[] args) {Student student = new Student();student = null;System.gc();//负责通知进行垃圾回收System.out.println("程序运行完毕");}
}class Student extends Object{public void finalize() throws Throwable { super.finalize();System.out.println("垃圾被回收了");}
}

toString 方法：打印对象的字符串形式，当打印一个对象的引用时会默认调用toString方法（必会的）
案例：
package cn.baizhi.day13;public class Demo5 {public static void main(String[] args) {Student student = new Student("刘洋",17);System.out.println(student);Object object = new Student("高健", 250);System.out.println(object);Object[] object2 = {new Student("赵四", 34),new Wo(),new Worker()};}
}class Student extends Object{String name;int age;public Student(String name, int age) {super();this.name = name;this.age = age;}//重写toString@Overridepublic String toString() {return "name:"+this.name+"---  age:"+this.age;}	
}
class Wo{	
}

getClass()：通过类的对象能够返回类对象
案例：package cn.baizhi.day13;public class Demo5 {public static void main(String[] args) {//创建一个学生对象//学生类的对象Student student1 = new Student();System.out.println(student1.hashCode());//通过学生类的对象获取学生类类对象Class c1 = student1.getClass();System.out.println(c1.toString());Student student2 = new Student();System.out.println(student2.hashCode());Class c2 = student2.getClass();System.out.println("============================");System.out.println(c1.hashCode());System.out.println(c2.hashCode());System.out.println(c1==c2);}
}class Student extends Object{String name;int age；	
}案例：
package cn.baizhi.day13;public class Demo5 {public static void main(String[] args) {Animal animal1 = new Dog();Animal animal2 = new Cat();System.out.println(animal1.getClass());System.out.println(animal2.getClass());System.out.println(animal1.getClass() == animal2.getClass());System.out.println(animal1 instanceof Dog && animal2 instanceof Dog);}
}class Student extends Object{}class Animal{}class Dog extends Animal{}class Cat extends Animal{}interface IA{}

equals：判断两个对象的内容是否相同
equals方法的重写步骤：1.判断 this 和obj地址是否相同2.判断obj是否为空3.判断是否是同类4.向下转型5.根据需求判断两个对象的属性是否相同注意：第2和3两步不能颠倒 否则会出现空指针异常案例：
package cn.baizhi.day13;public class Demo5 {public static void main(String[] args) {//创建两个学生对象Student student1 = new Student("高健", 250,"250250");Student student2 = new Student("刘洋", 16,"888888");Student student3 = new Student("高健", 25,"250250");//1  //简单的数据类型==比较的的数值是否相同/*int a = 10;int b =11;System.out.println(a==b);*///当两个学生的年龄相同 就认为是同一个人/*System.out.println(student1==student3);System.out.println(student1.equals(student3));*///试验一下字符串是否重写了equals/*String string1 = new String("高健");String string2 = new String("高健");System.out.println(string1==string2);//falseSystem.out.println(string1.equals(string2));//true
*/		//当三个属性都相同才为同一个对象System.out.println(student1.equals(student3));}
}class Student extends Object{String name;int age;String id;public  Student() {}public  Student(String name,int age,String id) {this.name = name;this.age = age;this.id = id;}@Overridepublic boolean equals(Object obj) {//向下转型Student student = (Student) obj;//判断if (this.name.equals(student.name)&& this.age==student.age && this.id.equals(student.id)) {return true;} else {return false;}}}案例：
package cn.baizhi.day13;public class Demo5 {public static void main(String[] args) {// 创建两个学生对象Student student1 = new Student("高健", 250, "250250");Student student3 = null;// Dog dog = new Dog();// 当三个属性都相同才为同一个对象System.out.println(student1.equals(student3));// 1 当两个引用中存放的是同一个地址 直接就可以返回true// 2 当 student3 = null// 简单的数据类型==比较的的数值是否相同/** int a = 10; int b =11; System.out.println(a==b);*/// 当两个学生的年龄相同 就认为是同一个人/** System.out.println(student1==student3);* System.out.println(student1.equals(student3));*/// 试验一下字符串是否重写了equals/** String string1 = new String("高健"); String string2 = new String("高健");* System.out.println(string1==string2);//false* System.out.println(string1.equals(string2));//true*/}
}class Student extends Object {String name;int age;String id;public Student() {}public Student(String name, int age, String id) {this.name = name;this.age = age;this.id = id;}@Overridepublic int hashCode() {final int prime = 31;int result = 1;result = prime * result + age;result = prime * result + ((id == null) ? 0 : id.hashCode());result = prime * result + ((name == null) ? 0 : name.hashCode());return result;}/** @Override public boolean equals(Object obj) { if (this == obj) return* true; if (obj == null) return false; if (getClass() != obj.getClass())* return false; Student other = (Student) obj; if (age != other.age) return* false; if (id == null) { if (other.id != null) return false; } else if* (!id.equals(other.id)) return false; if (name == null) { if (other.name* != null) return false; } else if (!name.equals(other.name)) return false;* return true; }*//** @Override public boolean equals(Object obj) {* * //1.当两个引用 this obj 地址相同直接就返回true if (this == obj) { return true; }* * //2 进行非空判断 if (obj==null||this==null) { return false; } //3 if* (this.getClass()!=obj.getClass()) { return false; } //向下转型 Student* student = (Student) obj;* * //判断 if (this.name.equals(student.name)&& this.age==student.age &&* this.id.equals(student.id)) { return true; } else { return false; } }*/@Overridepublic boolean equals(Object obj) {// 1 当this 和 obj 地址相同返回trueif (this == obj) {return true;}// 2 当obj==null falseif (obj == null) {return false;}// 3 判断两个对象的类型是否为同一个类型if (this.getClass() != obj.getClass()) {return false;}// 4 向下转型Student student = (Student) obj;// 5 根据开发需求 通过属性判断两个对象是否是同一个对象if (this.name.equals(student.name) && this.age == student.age&& this.id.equals(student.id)) {return true;} else {return false;}}}class Dog {}

总结

重点：toString equals面试题：== 和 equals区别答：简单数据类型判断的都是数值，引用数据类型在重写之前是一样的都是判断的是地址值，重写之后判断的是两个对象的内容是否相同，从而得到两个对象是否是同一个对象finalize()方法和getClass()了解

作业

1  7   8   9   26    除去String和包装类 全做必做作业：以下的代码 手写10遍
@Overridepublic String toString() {return "Student [name=" + name + ", age=" + age + ", id=" + id + "]";}@Overridepublic boolean equals(Object obj) {// 1 当this 和 obj 地址相同返回trueif (this == obj) {return true;}// 2 当obj==null falseif (obj == null) {return false;}// 3 判断两个对象的类型是否为同一个类型if (this.getClass() != obj.getClass()) {return false;}// 4 向下转型Student student = (Student) obj;// 5 根据开发需求 通过属性判断两个对象是否是同一个对象if (this.name.equals(student.name) && this.age == student.age&& this.id.equals(student.id)) {return true;} else {return false;}}1.
package cn.baizhi.day13;public class Demo3 {public static void main(String[] args) {//灯泡  接口的实现者/*class Red  implements LuoWen{@Overridepublic void shine() {System.out.println("发红光");}}class Green implements LuoWen{@Overridepublic void shine() {// TODO Auto-generated method stubSystem.out.println("发绿光");}}//定义一个匿名的局部内部类class (假装没有名字) implements LuoWen{public void shine() {// TODO Auto-generated method stubSystem.out.println("发黄光");}}*///买一个台灯Lamp lamp = new Lamp();//买一个灯泡//Green green = new Green();//将灯泡安到台灯上并打开通电lamp.on(new LuoWen(){public void shine() {// TODO Auto-generated method stubSystem.out.println("发黄光");}});lamp.on(new LuoWen() {@Overridepublic void shine() {// TODO Auto-generated method stubSystem.out.println("发绿光");}});}
}//定义一个接口
interface LuoWen{//通电void shine();
}class Lamp{//接口的使用者//开关public void on(LuoWen luoWen) {luoWen.shine();}}26.
package cn.baizhi.day13;public class Demo4 {public static void main(String[] args) {Inter inter = MyClass.method();inter.show();}
}//定义一个接口
interface Inter{void show();
}
//定义一个类
class MyClass{//代码//返回一个inter接口的实现类对象public static Inter method() {Inter inter = new Inter() {@Overridepublic void show() {System.out.println("hello world");}};return inter;}
}