一、内部类
1、概念:如果一个事物的内部包含另一个事物,那么这就是一个类内部包含另一个类。
- 例如:身体和心脏的关系,又如汽车和发动机的关系。
2、分类
- 成员内部类、局部内部类(包含匿名内部类)
3、成员内部类
(1)定义格式:
修饰符 class 外部类名称{
修饰符 class 内部类名称{
//...
}
//...
}
- 注意:内用外,随便访问。外用内,需要内部类对象。
(2)使用
- 间接使用:在外部类的方法中,使用内部类,然后主函数只是调用外部类的方法。
- 直接方式:
外部类名称.内部类名称 对象名=new 外部类名称().new 内部类名称();
//创建一个外部类用来储存学生的初始属性
public class students_score {
public students_score(String name) {
this.name = name;
}
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//定义一个外部类方法
public void show(){
System.out.println("你的姓名为:"+getName());
//在外部类方法中创建一个内部类对象
subject_score stu1=new subject_score();
stu1.show_score("math",68);
}
//定义一个内部类
public class subject_score{
//定义一个内部类方法
public void show_score(String subject,double score){
//内部可以直接调用外部类的方法和成员变量
//如show(zhangsan),以及下面的getName
System.out.println(getName()+",你的科目为:"+subject);
System.out.println(getName()+",你的成绩为:"+score);
}
}
}
public class score {
public static void main(String[] args) {
//间接访问:创建外部类,但要求外部类的方法中包括内部类,通过访问外部类的方法来访问内部类
students_score stu1 = new students_score("zhangsan");
stu1.show();
//直接访问,利用公式
students_score.subject_score stu2 =new students_score("lisi").new subject_score();
stu2.show_score("history",89);
}
}
输出为:
你的姓名为:zhangsan
zhangsan,你的科目为:math
zhangsan,你的成绩为:68.0
lisi,你的科目为:history
lisi,你的成绩为:89.0
(3)内部类的同名变量访问
- 局部变量采用就近原则。
- 内部类的成员变量使用this(谁用就是谁)
- 外部类的成员变量:
外部类名称.this.成员变量名
- 例如:
public class number {
int number =10;
public class num{
int number=20;
public void num0(){
System.out.println(number);//20
System.out.println(this.number);//20
System.out.println(number.this.number);//10
}
}
}
public class main2 {
public static void main(String[] args) {
number.num number0 = new number().new num();
number0.num0();
}
}
//输出为:20 20 10
4、局部内部类
(1)定义:如果一个类是定义在一个方法内部的,那么这就是一个局部内部类
- 局部:只有当前所属的方法才能使用它,出了这个方法外面就不能再使用了。
//定义格式:
修饰符 class 外部类名称{
修饰符 返回值类型 外部类方法名称(参数列表){
class 局部内类名称{
//...
}
}
}
(2)类的权限修饰符:
- public > protected > (defualt) > private
(3)定义一个类的时候,权限修饰符规则
- 外部类:public/(default)
- 成员内部类:public/ protected/(default)/private
- 局部内部类:什么都不写
//创建一个局部类:定义在方法中的类
public class suiyuan {
public void method(){
class suibian{
int num =10;
public void m(){
System.out.println(num);
}
}
//创建一个内部类
suibian bian=new suibian();
bian.m();
}
}
public class sui {
public static void main(String[] args) {
suiyuan yang = new suiyuan();
//yang.method();
/*只能调用创建的外部类的方法,不能调用方法的内部类
如果需要调用内部类方法需要在外部类方法内调用*/
yang.method();
}
}
//输出结果为10
(4)局部内部类的final问题
- 局部内部类如果希望访问所在方法的局部变量,那么这个局部变量必须是【有效final的】,实际就是将变量变成常量。
- 从Java8开始只要局部变量事实不变,那么这个final关键字可以省略。
- 原因:
- new出来的对象在堆内存中
- 局部变量是跟着方法走的,在堆内存中
- 方法运行结束之后,立刻出栈,局部变量就会立刻消失
- new出来的对象会在堆当中持续存在,直到垃圾回收消失。
public class a {
public void method(){
final int num =10;//final可以省略
class b{
public void m(){
System.out.println(num);
}
}
}
}
5、匿名内部类
- 如果接口的实现类或者是父类的子类只需要使用的唯一一次,那么这种情况下就可以省略掉该类的定义,而改为使用【匿名内部类】。
(1)匿名内部类的定义格式:
接口名称 对象名 =new 接口名称(){
覆盖重写所有抽象方法
}
//定义一个接口并定义一个抽象方法
public interface a {
void method();
}
public class b {
public static void main(String[] args) {
a sui = new a() {
@Override
public void method() {
System.out.println("方法实现!");
}
};
sui.method();
}
}
//输出为:方法实现!
(2)匿名内部类注意事项
- new代表创建对象的动作
- 接口名称就是匿名内部类需要,大括号内是匿名内部类的内容
- 匿名内部类,在创建对象的时候只能使用唯一的一次。如果希望多次创建对象而且类的内容一样的话,那么就必须使用单独定义的实现类了。
- 匿名对像在调用方法的时候只能能调用唯一一次。如果希望同一对象调用多次方法,那么必须给对象取名。
- 匿名内部类省略了实现类/子类,匿名对象是省略了对象名称。
- 注意,匿名内部类和匿名对象不是同一件事。
public class c {
public static void main(String[] args) {
new a() {
@Override
public void method() {
System.out.println("匿名对象使用了方法!");
}
}.method();//如果需要调用多次方法,建议为对象命名。
}
}
//输出为:匿名对象使用了方法!
6、类作为成员变量类型
- 类也可也作为成员变量被使用
public class only {
private String onlyone;
public only(){
}
public only(String onlyone) {
this.onlyone = onlyone;
}
public String getOnlyone() {
return onlyone;
}
public void setOnlyone(String onlyone) {
this.onlyone = onlyone;
}
}
public class people {
private String name;
private int age;
//将only类作为一个成员变量
private only gexing;
public people(){
}
public people(String name, int age, only gexing) {
this.name = name;
this.age = age;
this.gexing = gexing;
}
public void girl (String girlname){
System.out.println(name+age+"岁"+",喜欢"+gexing.getOnlyone() +",他的女朋友叫"+girlname);
}
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 only getGexing() {
return gexing;
}
public void setGexing(only gexing) {
this.gexing = gexing;
}
}
public class person {
public static void main(String[] args) {
people man=new people();
man.setName("张三");
man.setAge(20);
only a=new only("吉他");
man.setGexing(a);
man.girl("MIss who.");
}
}
//输出结果为:张三20岁,喜欢吉他,他的女朋友叫MIss who
7、接口作为成员变量类型
public interface gituar {
void perform();
}
public class person {
private String name;
//将gituar作为成员变量
private gituar song;
public person() {
}
public person(String name, gituar song) {
this.name = name;
this.song = song;
}
public void tan(String girlname,String songname){
System.out.println(name+"用吉他为"+girlname+"谈唱一首"+songname);
song.perform();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public gituar getSong() {
return song;
}
public void setSong(gituar song) {
this.song = song;
}
}
public class catchheart {
public static void main(String[] args) {
person man=new person();
man.setName("李四");
man.setSong(new gituar() {
@Override
public void perform() {
System.out.println(man.getName()+"俘获了她的心");
}
});
man.tan("不知道小姐","往后余生");
}
}
/*输出为:李四用吉他为不知道小姐谈唱一首往后余生
李四俘获了她的心*/
8、接口作为参数的方法和返回值
- 例如,java.util.list正是ArrayList所实现的接口
import java.util.ArrayList;
import java.util.List;
public class suiyuan {
public static void main(String[] args) {
//左边是接口名称,右边是实现类名称
List<String> lady= new ArrayList<>();
List<String> girls=name(lady);
//遍历集合
for (int i = 0; i < girls.size(); i++) {
System.out.println(girls.get(i));
}
}
//将接口作为返回值类型和参数名称
public static List<String> name(List<String> list){
list.add("不知道小姐");
list.add("Miss Who");
list.add("找不到女士");
return list;
}
}
//输出结果为:
不知道小姐
Miss Who
找不到女士
二、Object类
- Object类是Java语言中的根(最顶层)类,及所有类的父类。它中描述的所有方法子类都可以使用,在对象实例化时,最终找的父类就是Object。
- 如果一个类没有特别指定父类,那么默认就是继承Object类。
1、Object的to String方法
- to String()返回该对象的字符串表示。直接打印对象的名字其实就是调用to String方法,打印的实际为对象的地址值。因此需要重写Object类的toString方法。
- 重写时可以使用快捷键(alt+insert)直接重写。
- 看一个类是否重写了toString方法,直接打印这个类对应的对象名字即可。如果没有重写则打印地址值,如果重写了toString方法,那么就按照重写的方式打印。
public class person {
private String name;
private int age;
public person(){
}
public person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
//重写toString方法
public String toString() {
return "person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
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;
}
}
import java.util.ArrayList;
import java.util.Random;
public class a {
public static void main(String[] args) {
person p=new person();
p.setAge(18);
p.setName("张三");
System.out.println(p);
Random r = new Random();
//因为Random没有重写toString方法,所以输出的结果为地址值。
System.out.println(r);
ArrayList<Integer> list =new ArrayList<>();
list.add(1);
list.add(2);
//Arraylist重写了toString方法,输出结果为集合
System.out.println(list);
}
}
person{name='张三', age=18}
java.util.Random@52cc8049
[1, 2]
2、Object类的equals方法
- 指示某个对象是否与此对象相等
public class b {
public static void main(String[] args) {
person a=new person("zhaosi",19);
person b=new person("zhangsan",19);
boolean c=a.equals(b);
System.out.println(c);
/*基本类型:比较值
引用类型:比较地址值
所以输出的结果为false
*/
}
}
3、重写Object类的equals方法
- Object类的equals方法的地址值,没有意义。所以我们需要重写equals方法,比较两个对象的属性值。
- equals方法中隐含一个多态,因此需要使用向下转型。
- 重写时可以直接使用快捷键,建议使用JDK版本
@Override
public boolean equals(Object o) {
if (this == o) return true;//判断是否为本身
if (o == null || getClass() != o.getClass()) return false;//判断是否为空
person person = (person) o;//向下转型
return age == person.age &&
name.equals(person.name);
}
person a=new person("zhaosi",19);
person b=new person("zhaosi",19);
boolean c=a.equals(b);
System.out.println(c);
//输出为true
- Objects类的equals方法:对两个对象进行比较可以防止空指针异常
public class c {
public static void main(String[] args) {
String s1="aaa";
String s2=null;
boolean a= Objects.equals(s1,s2);
System.out.println(a);
}
}
//输出结果为false
4、Object类与Objects类
(1)Object类
- Object类是所有类的父类,一个类都会直接或间接的继承自该类中提供了一些非常常用的方法。
- toString()方法equals()方法
(2)Objects类
- equals方法