一、形式参数和返回值问题案例
（1）形式参数：a. 基本类型
b. 引用类型
1. 类：要的是该类的对象
2. 抽象类：需要抽象类的子类对象，因为抽象类不能直接实例化
3. 接口：不能直接实例化，只能通过接口多态形式，需要传递的是接口的子实现类对象
（2）返回值类型： a. 基本类型
b．引用类型
1. 类：返回的是该类对象
2. 抽象类：返回的不应该是该抽象类的对象（不能实例化），返回抽象类的子类对象
3. 接口：需要返回的是接口的子实现类对象
二、类及其组成可以用的修饰符
权限修饰符：public , protected ,默认，private
（1）类：默认，public，final，abstract
我们自己定义：public居多
（2）成员变量：四种权限修饰符均可,final,static
我们自己定义：private居多
（3）构造方法：四种权限修饰符均可,其他不可
我们自己定义：public 居多
（4）成员方法：四种权限修饰符均可，fianl,static,abstract
我们自己定义：public居多
三、内部类
（1）内部类的概述：将一个类定义到其他类中,把这个类称为内部类
举例：在A类中定义一个B类,把B类叫A类的内部类,A类属于B类的外部类
（2）内部类的访问特点：
a. 内部类是直接可以访问外部类的成员的,包括私有
b. 外部类的成员要访问内部类的成员,不能直接访问,需要创建内部类对象,使用对象去调用内部类的成员方法
（3） 内部类的分类：
A: 成员内部类：在类中的成员位置
⒈访问成员内部类外界如何创建对象？
外部类名.内部类名对象名 =外部类对象.内部类对象;
⒉成员内部类的常见修饰符以及访问方法：
① private 为了保证数据的安全性
② static 为了让数据访问更方便
③ 被静态修饰的成员内部类只能访问外部类的静态成员
④ 内部类被静态修饰后的方法的访问:
访问非静态方法：外部类名.内部类名对象名 = new外部类名.内部类名();
访问静态方法：上面创建的对象访问，或者外部类名.内部类名.方法名();
【举例】
class Outer{
//外部类的成员变量
private int num = 10 ;
private static int num2 = 20 ;
//静态的成员内部类
public static class Inner4{
//非静态的成员方法
public void show(){
// System.out.println(num);
System.out.println(num2);
}
//成员静态内部类,静态成员方法
public static void show2(){
System.out.println(num2);
// System.out.println(num);
}
}
}
//测试类
public classInnerClassDemo4 {
public static void main(String[] args) {
//访问静态成员内部类里面:show()和show2()
//外部类名.内部类名对象名=外部类.内部类对象;
// Outer4.Inner4 oi = new Outer4().newInner4();
// oi.show();
// oi.show2();
//对于静态的成员内部类访问里面的成员的方式:
//外部类名.内部类名对象名 = new外部类名.内部类名();
Outer4.Inner4 oi2 = newOuter4.Inner4();
oi2.show();
oi2.show2();
//show2()有另外一种访问方式:
Outer4.Inner4.show2() ;
}
}
B: 局部内部类：在局部位置
1. 局部内部类也是可以直接访问外部类的成员,包括私有
在局部位置要访问内部类的成员方法,要通过创建内部类对象,使用内部类对象去调用这个方法
2. 面试题:
局部内部类访问局部变量局部变量必须被final修饰,为什么？ (jdk1.8以下)
局部变量随着方法调用而存在,随着方法的调用完毕而消失
但堆内存中的对象不会立即消失,等待GC垃圾回收线程空闲的时候才被回收掉,
Final修饰则是告诉GC垃圾回收器,内部类正在访问这个数据,正在使用(需要定义为自定义常量,而是一个常量)
②
（4）内部类和外部类没有继承关系：由以下程序可知
class Outer {
publicint num = 10;
classInner {
publicint num = 20;
publicvoid show() {
intnum = 30;
System.out.println(num);
System.out.println(this.num);
System.out.println(Outer.this.num);
//外部类名.this.成员变量:用来限定this表示自己对象
}
}
}
class OuterDemo {
publicstatic void main(String[] args) {
Outer.Inneroi = new Outer().new Inner();
oi.show();
}
}
（5）匿名内部类 (开发中经常使用): 起始就是内部类的简化格式
a. 格式:new类或者接口{
重写或者实现一些方法
};
类:可以是抽象类,也可以是具体类
存在一个接口/抽象类,然后去使用匿名内部类的方式进行操作
b. 匿名内部类的本质：继承了该类或者是实现该接口的子类匿名对象!
c. 匿名内部类案例：
interface Inter{
publicabstract void show();
publicabstract void show2();
}
//外部类
class Outer6{
//成员方法
publicvoid method(){
//匿名内部类:
Interi = new Inter() {//相当于接口的子实现类:接口多态的形式
@Override
publicvoid show2() {
System.out.println("show2inter");
}
@Override
publicvoid show() {
System.out.println("showinter");
}
};
i.show();
i.show2();
}
}
//测试类
public class InnerClassDemo6 {
publicstatic void main(String[] args) {
//调用show2(),show1()方法如何操作
Outer6o = new Outer6() ;
o.method();
}
}
d. 在开发中的应用：
interface Person{
publicabstract void study() ;
}
class PersonDemo{
publicvoid method(Person p){
p.study();
}
}
//子实现类
class Student implements Person{
@Override
publicvoid study() {
System.out.println("学习爱学习,爱生活");
}
}
//测试类
public class InnerClassTest2 {
publicstatic void main(String[] args) {
//需求:调用PersonDemo中的method()方法
//需要创建接口的子实现类
//1)创建PersonDemo类的对象
PersonDemopd = new PersonDemo() ;
//接口多态的方式:通过子实现类对象进行实例化
Personp = new Student() ;
pd.method(p);
System.out.println("-------------------");
//匿名内部类:方式2:常用!
//本质:是继承该类或者是实现了该接口的子类的匿名对象
PersonDemopd2 = new PersonDemo() ;
pd2.method(newPerson() {//匿名内部类的方式!
@Override
publicvoid study() {
System.out.println("学习爱学习,爱生活");
}
});
}
}