一：java方法参数的传递：
方法参数的传递类型由基本类型与引用类型组成;
基本类型：基本数据类型（如int ,double 等）
引用类型：类，接口，对象；
（1）基本类型
举例：
public class Test {
public static void change(int i, int j) {
int temp = i;
i = j;
j = temp;
}
public static void main(String[] args) {
int a = 3;
int b = 4;
change(a, b);
System.out.println("a=" + a);
System.out.println("b=" + b);
}
}
结果： 
基本类型并不会引起初始值的改变。
（2）引用类型
如果你看到一个方法参数需要一个类的类型，那么你要传一个类的子类对象；
如果你卡到一个方法参数需要一个抽象类的类型，那么你需要传递一个抽象类的子类对象；
如果你看到一个方法参数需要一个接口的类型，那么你需要传递一个接口的子类对象。
举例：
Person类：
public abstract class Person {
public int num=100;
public abstract void eat();
}
Student 类：
public class Student extends Person implements MyInterface {
private String name;
private int age;
public int num = 1;
public int a=600;
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String name, int age) {
super();
this.name = name;
this.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;
}
@Override
public void eat() {
System.out.println("我爱吃麻辣烫");
}
@Override
public void haha() {
System.out.println("我实现了一个haha方法");
}
}
接口：
public interface MyInterface {
int a=500;
public abstract void haha();
}
Test 类：
public class MyTest {
public static void main(String[] args) {
// 如果以后你看大一个方法要一个类 类型，传该类的对象
Student student = new Student();
setStudent(student);
System.out.println(student.getName());// abc
System.out.println(student.getAge());// 30
System.out.println("----------------------------------------------");
// 如果你以后看到一个方法的参数需要一个抽象类类型，传一个抽象类的子类对象
setStudent2(new Student());
System.out.println("---------------------------");
// 如果你以后看到一个方法的参数要一个接口类型，你传一个该接口的子类对象
setStudent3(new Student());
}
private static void setStudent(Student s) {
s.setName("abc");
s.setAge(30);
}
private static void setStudent2(Person s) {
s.eat();
}
private static void setStudent3(MyInterface s) {
s.haha();
}
}
结果：
二：权限修饰符
（1）四种权限修饰符
private(私有的) , 默认 , protected(受保护的) , public(公共的)
本类 同一个包下 (子类和无关类) 不同包下(子类) 不同包下(无关类)
private Y
默认 Y Y
protected Y Y Y
public Y Y Y Y
A:修饰符：
权限修饰符：private，默认的，protected，public
状态修饰符：static，final
抽象修饰符：abstract
B:修饰类：
权限修饰符：默认修饰符，public
状态修饰符：final
抽象修饰符：abstract
用的最多的就是：public
C:成员变量：
权限修饰符：private，默认的，protected，public
状态修饰符：static，final
用的最多的就是：private
D:构造方法：
权限修饰符：private，默认的，protected，public
用的最多的就是：public
E:成员方法：
权限修饰符：private，默认的，protected，public
状态修饰符：static，final
抽象修饰符：abstract
用的最多的就是：public
F:除此以外的组合规则：
成员变量：public static final
成员方法：public static
public abstract
public final
三：内部类
（1）定义：把一个类的定义在另一个类的内部这个内部的类就叫内部类
(2) 访问特点：内部类可以直接访问外部类的成员，但是外部 类要想访问内部类的话 就必须创建一个内部类的对象。
(3)创建一个内部类的格式为:Outer.Inner inner = new Outer().new Inner(); 外部类为Outer内部类为Inner。外部类名.内部类名 对象名 = 外部类对象.内部类对象;
（4）内部类的分类为;成员位置:在成员位置定义的类，被称为成员内部类。 局部位置:在局部位置定义的类，被称为局部内部类。
举例：
成员内部类：
class Outer {
public int num = 10;
class Inner {
public int num = 20;
public void show() {
int num = 30;
System.out.println(num);// 30
System.out.println(this.num);// 20
System.out.println(new Outer().num);// 10
}
}
class InnerClassTest {
public static void main(String[] args) {
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}
结果：
局部内部类的理解 ：
A: 可以直接访问外部类的成员
B: 可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能
C:局部内部类访问局部变量必须用final修饰为什么呢?
因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值。
举例：
class Outer {
// 成员变量
private int a = 45 ;
// 成员方法
public void show() {
// 定义一个局部变量
final int b = 45 ;//JDK1.7之前要加final不然报错 但是在JDK1.8 不用加 不会报错
// 局部内部类
class Inner {
public void method(){
System.out.println(a) ;
System.out.println(b) ;
}
}
// 创建对象
Inner i = new Inner() ;
// 调用放
i.method() ;
}
}
// 测试类
class InnerClassDemo6 {
public static void main(String[] args) {
// 创建Outer的对象
Outer out = new Outer() ;
// 调用show方法
out.show() ;
}
}结果:
四：匿名内部类
（1）定义：就是局部内部类的简化写法。
（2）使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或者实现一个接口。
（3）匿名内部类中是不能定义构造函数的。
（4）匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。