笔记(4月16日)

一：形式参数问题
数据类型：
基本类型：byte,short,int,long,float,double,char,boolean
引用类型：类,接口,数组


形式参数：
基本类型：要的是该基本类型的数据值。
引用类型：要的是该引用类型的对象。
A:数组 要的是该数据类型数组的对象。(地址值)
B:类   要的是该类或者其子类的对象。(地址值)
C:抽象类 要的是该抽象类的子类对象。(地址值)
D:接口 要的是该接口的实现类对象。(地址值)




二：返回值问题
返回值：
基本类型：byte,short,int,long,float,double,char,boolean
引用类型：类，接口，数组


返回值之基本类型：
基本类型：返回的是该基本类型的数据值。
案例：创建一个加法的方法，返回值就是基本类型的具体的指

返回值之引用类型：
返回值是类名：其实返回的是该类对象或者其子类对象。(地址值)
返回值是抽象类名：要的是该抽象类的子类对象。(地址值)
返回值是接口名：要的是该接口的实现类对象。(地址值)


三：权限修饰符（代码进行测试）
权限修饰符：在哪种情况下可以被访问到。
本类     同一个包下的类  不同包下的子类 不同包下的无关类
private yes no no no
默认(什么都不写)         yes yes no no
protected yes             yes           no no
public yes             yes yes yes




四：常见的内容修饰
1:常见的修饰

类：public
public class HelloWorld {}


成员变量：private
private String name;
private int age;


构造方法：public
public Student() {}
public Student(String name,int age) {}


成员方法：public
public void show() {}
public void eat() {}


2:哪些东西可以修饰哪些东西
    类 成员变量 构造方法 成员方法
private Y      Y Y
默认 Y Y      Y Y
protected Y      Y Y
public Y Y      Y Y
static Y Y
final Y Y Y
abstract Y Y


注意：
四种权限修饰符，只能有一种存在。


class Demo {}


常见的组合：
类：
public class HelloWorld {}
public final class HelloWorld {}
public abstract class HelloWorld {}


成员变量：
private String name;
public final int X = 10;
public static int y = 20;
public static final int X = 30;

成员方法：
public void show(){}
public abstract void show();
public final void show(){}
public static void show() {}
public static final void show() {}


五：内部类
5.1
内部类：
把类A定义在类B的内部，类A就被称为内部类。


访问特点：（代码验证只要编译通过说明就是没有问题的）
A:内部类可以直接访问外部类的成员，包括私有。

B:外部类要访问内部类的成员，必须创建对象。

例：//创建一个外部类
class Outer{
//私有画的成员变量
private int num = 20;

//创建一个内部类
class Inner{
//创建一个show方法，访问外部类的私有化的成员变量
public void show(){
System.out.println(num);//内部类的成员可以直接访问外部类的成员，包括私有
}
}

//创建一个成员方法，访问内部类的show方法
public void function(){
//创建内部类的对象，访问内部类的成员方法
Inner i = new Inner();
i.show();
}
}


public class InnerClassDemo {
public static void main(String[] args) {
//创建一个外部类对象，调用他的function方法
Outer o = new Outer();
o.function();
}


}

5.2
内部类分类：
成员位置：成员内部类
局部位置：局部内部类

5.2.1
成员内部类：
外界如何创建对象


外部类名.内部类名 对象名 = 外部类对象.内部类对象;


5.2.2
内部类的关键词限定：
内部类举例：
Body,Heart
//A:private 为了我们访问数据的安全性
class Body {
private class Heart {
public void operator() {
System.out.println("给心脏搭个桥");
}
}


public void method() {
if(你是医生吗?) {
Heart h = new Heart();
h.operator();
}
}
}


直接访问：
Body.Heart bh = new Body().new Heart();
bh.operator();


为了身体的安全，外界是不能让他们直接创建对象。通过private进行修饰。
这个时候就可以这样来使用：
Body b = new Body();
b.method();


成员内部类的修饰：
A:private 为了我们访问数据的安全性
B:static  为了我们访问数据的方便性


5.2.3
//B:static  为了我们访问数据的方便性
class Outer {


public static class Inner {
public void show() {
System.out.println("show");
}


public static void show2() {
System.out.println("show2");
}
}


}


class InnerClassDemo3 {
public static void main(String[] args) {
// 限定的新静态类
//Outer.Inner oi = new Outer().new Inner();
//格式：
Outer.Inner oi = new Outer.Inner();
oi.show();
oi.show2();


//Outer.Inner.show();
Outer.Inner.show2();
}
}


5.2.4
面试题：
/*
需求：请补齐代码，在控制台输出30,20,10
*/
class Outer {
public int num = 10;


private class Inner {
public int num = 20;
public void show() {
int num = 30;
System.out.println(？);//num
System.out.println(？);//this.num
System.out.println(？);//new Outer().num或者Outer.this.num
}
}


public void method() {
Inner i = new Inner();
i.show();
}
}


class InnerClassTest {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}



5.3
局部内部类：
A:可以直接访问外部类的成员，包括私有
B:在成员方法中创建局部内部类的对象，调用局部内部类的功能


面试题：
从内部类中访问本地变量number; 需要被声明为最终类型?


为什么：局部内部类访问局部变量必须加final修饰呢?
因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。
为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值。

5.4
匿名内部类
没有名字的局部内部类,就是内部类的简化写法


前提：
存在一个类或者接口
这里的类可以是具体类也可以是抽象类。


格式：
new 类名或者接口名() {
重写方法;
};


本质：
是一个继承了类或者实现了接口的子类匿名对象。

5.5
匿名内部类在开发中的实际应用。
案例演示：传入的方法的参数是一个接口（方式一：定义一个已经实现了接口的类  方式二：匿名内部类的方式）
package com.edu_06;

interface Person2{
public abstract void eat();
}


class Man2 implements Person2{
@Override
public void eat() {
System.out.println("男人都爱吃泡馍");
}
}


class Person2Demo{
//创建一个方法，方法的参数是一个接口类型
public void show(Person2 p){
p.eat();
}
}




public class InnerClassDemo4 {
public static void main(String[] args) {
//调用Person2Demo中的show方法
Person2Demo pd2 = new Person2Demo();
pd2.show(new Man2());//传入接口的实现类对象

System.out.println("--------------------");
//使用匿名内部类的方式进行传参
pd2.show(new Person2(){//这里的匿名内部类，本质上就是实现了Person2这个接口的一个实现类对应的匿名对象
@Override
public void eat() {
System.out.println("我爱吃油泼面");
}
});
}


}

5.6面试题
/*
按照要求，补齐代码
interface Inter { void show(); }
class Outer { //补齐代码 }
class InnerClassTest {
public static void main(String[] args) {
 Outer.method().show();
 }
}
要求在控制台输出”HelloWorld”
*/
答案：
interface Inter { 
void show(); 
}

class Outer { 

public static Inter method () {

return new Inter () {

public void show(){

System.out.println("HelloWorld")

}

};

}

}


class InnerClassTest {
public static void main(String[] args) {
 Outer.method().show();
}
}