方法参数类型以及返回值问题
1.形式参数是基本类型要的是一个基本类型的变量或者具体的常量值；（1）是类名的时候要的是一个该类的对象；（2）是抽象类名的时候的要的是一个继承自该类的一个子类对象；（3）是接口的时候要的是一个实现了该接口的子类对象；
2.返回值是基本数据类型的时候返回的是一个具体的值；（1）是类名的时候,本质上返回的是一个该类对应的子类对象；（2）是抽象类名的时候返回的应该是一个继承自该类的子类对象；（3）是接口名的时候返回的是一个实现了该接口的子类对象；
3.注意：基本数据类型作为参数传递时，形参的改变不会影响实参，而引用数据类型作为参数传递时，形参的改变会影响实参！！！
链式编程
链式编程就是把多个方法使用点语法链接起来，只要结尾为一个对象就可以继续调用方法；
链式编程的优点：编程性强、可读性强、代码简洁；但是不太利于代码的调试；
普通写法：
Tiger tiger = new Tiger();
Tiger tiger1 = tiger.getTiger(new Tiger(), 10);
int age1 = tiger1.getAge();
链式编程：
int age = new Tiger().getTiger(new Tiger(), 10).getAge();
package、import
package为包的意思，本质为一个文件夹，包可以按照功能或者模块来划分，用来进行分类管理管理；
注意事项:(1)package语句必须是程序的第一条可执行的代码;(2)package语句在一个java文件中只能有一个(3)如果没有package，则默认表示无包名；
import：不同包下类之间的访问；
权限修饰符
四种权限修饰符：private(私有的) , 默认 , protected(受保护的) , public(公共的)
private ：私有的只能在本类使用
默认：可以在本类和同一包下（子类和无关类使用
protected：可以在本类、同一个包下(子类和无关类)、不同包下（子类）
public：可以在所有情况下使用，包括不同包下
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.外部类要访问内部类的成员必须要创建对象
内部类分类：按照内部类位置分为：成员内部类和局部内部类
访问内部类成员格式：外部类名.内部类名 对象名=外部类对象.内部类对象
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(Outer2.this.num);//10//注意这种语法
}
}
}
class InnerClassTest {
public static void main(String[] args) {
Outer2.Inner oi = new Outer2().new Inner();//直接访问内部类成员
oi.show();
}
}
成员内部类的修饰符：private：为了保证数据的安全性；static：为了方便访问数据；
注意事项：1.静态内部类访问外部类必须是静态的；2.成员方法可以是静态的也可以是非静态的；3.内部类的静态方法使用类名即可调用
成员内部类被静态修饰后的访问方式：外部类名.内部类名 对象名 = new 外部类名.内部类名();
static int num=100;
//static 可以修饰内部类
// 静态内部类只能访问外部类的静态成员
public static class NeiClass{
public void innerShow(){
System.out.println("我是内部类的show方法");
System.out.println(num);
hehe();
}
public static void innerTest(){
System.out.println("我是内部类的静态方法");
}
public void test(){
System.out.println("我是内部类的静态方法");
}
}
public static void hehe(){
System.out.println("我是外部类的静态hehe方法");
//内部类的静态方法,类名就可以调用
NeiClass.innerTest();
//外部类访问内部类的方法，创建内部类对象
NeiClass neiClass = new NeiClass();
neiClass.test();
}
}
public class Test4 {
public static void main(String[] args) {
//创建静态内部类的语法
WaiClass.NeiClass neiClass=new WaiClass.NeiClass();
neiClass.innerShow();
}
}
局部内部类访问局部变量必须使用final修饰；局部内部类可以直接访问外部类的成员；可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能
原因：因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值。
// 成员变量
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();
}
public static void main(String[] args) {
// 创建Outer的对象
Outer out = new Outer() ;
// 调用show方法
out.show() ;
}
}
匿名内部类
匿名内部类：就是局部内部类的简写方法；
匿名内部类的前提：存在一个类或者接口;这里的类可以是具体类也可以是抽象类；
书写格式：new 类名或者接口名{
重写方法；
}
匿名内部类的本质：是一个继承了类或者实现了接口的子类匿名对象；
public static void main(String[] args) {
//匿名内部类:他是局部内部类的简写方式
//匿名内部类本质是一个对象,是谁的对象呢?是实现了该接口或继承了该抽象类的子类对象
//匿名内部类的语法
new Animal() {
@Override
public void show() {
System.out.println("我重写了show方法");
}
}.show();
testMethod(new Animal() {
@Override
public void show() {
System.out.println("我又重写了show方法");
}
});
// testMethod(new Dog());
}
private static void testMethod(Animal an) {
an.show();
}
}