java视频学习笔记-5-（形参和返回值，包，修饰符，内部类）

1. 形式参数和返回值案例

（1）形式参数：基本类型和引用类型（类（需要的是该类的对象），抽象类（需要的是该抽象类的子类对象），接口）

//类作为形式参数
abstract class Person {
	public abstract void study();
}

class PersonDemo{
	public void method(Person p) {
		p.study();
	}
}

//定义一个具体的学生类
class Student extends Person {
	public void study() {
		System.out.println("好好学习");
	}
}

class PersonTest {
	public static void main(String[] args) {
		//要使用抽象类，需要先定义一个具体类
		//需求：使用PersonDemo类中的method方法
		PersonDemo pd = new PersonDemo();
		//抽象通过多态的方式实现
		Person p = new Student();
		pd.method(p);
	}
}

（2）返回值类型：基本类型和引用类型（抽象类返回的应该是子类对象  ）
（3）链式编程：对象调方法再调方法。每次调用完毕后，返回的是一个对象

class Person {
	public void study() {
		System.out.println("好好学习");
	}
}

class PersonDemo {
	public Person getPerson() {
		return new Person();
	}
}


class PersonTest {
	public static void main(String[] args) {
		PersonDemo pd = new PersonDemo();
		//链式编程，方法调方法
		pd.getPerson().study();
	}
}

2. 包

其实就是文件夹
作用：
（1）把相同的类名放到不同的包中
（2）对类进行分类管理（在按模块分类的基础上按照功能分）
格式：package 包名;    多级包用，分开即可 例：package it.cast
注意事项：
（1）package语句必须是程序的第一条可执行的代码
（2）package语句在一个java文件中只能有一个
（3）如果没有package，默认表示无包名
带包的编译和运行：自动式为javac编译的时候带上-d
导包：
格式：import 包名 这种方式导入是到类的名称

3. 修饰符

权限修饰符：public protected 默认 private

状态修饰符：static final
抽象修饰符：abstract
类：（用的最多的public）
（1）权限修饰符：默认修饰符， public   
（2）状态修饰符：static final 
（3）抽象修饰符：abstract
成员变量：（用的最多的是private）
（1）权限修饰符：默认修饰符，public ,protected public
（2）状态修饰符：static final
构造方法：（用的最多的是public）
（1）权限修饰符：默认修饰符，public ,protected public
成员方法：（用的最多的public）
（1）权限修饰符：默认修饰符，public ,protected public
（2）状态修饰符：static final 
（3）抽象修饰符：abstract

4. 内部类

把类定义在其他类的内部
内部类的访问特点：
（1）内部类可直接访问外部类的成员，包括私有
（2）外部类要访问内部类的成员，必须创建对象

内部类的位置：
（1）成员位置（成员内部类） 访问格式为：外部类名.内部类名 对象名 =  外部类对象.内部类对象;

class Outer {
	private int num = 10;
	
	class Inner {
		public void show() {
			System.out.println(num);
		}
	}
}

class InnerclassDemo {
	public static void main(String[] args) {
		//需求：我要访问Inner类的show()方法
        //外部类名.内部类名 对象名 =  外部类对象.内部类对象;
		Outer.Inner oi = new Outer().new Inner();
		oi.show();
	}
}

成员内部类的修饰符：
（1）private为了保证数据的安全性
（2）static为了让数据访问更方便（被静态修饰的成员内部类只能访问外部类的静态成员）
         成员内部类被静态修饰后的访问方式为：  外部类名.内部类名 对象名 = new 外部类名.内部类名();
         Outer.Inner oi = new Outer.Inner();
注意：内部类和外部类没有继承关系

（2）局部位置（局部内部类）
可以直接访问外部类的成员；在局部位置，可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能

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

class Outer {
	private int num = 10;
	private final int num2 = 20;
	
	public void method() {
		class Inner {
			public void show() {
				System.out.println(num);
				System.out.println(num2);
			}
		}
		//创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能
		Inner i = new Inner();
		i.show();
	}
	
}

class InnerclassDemo {
	public static void main(String[] args) {
		//需求：我要访问Inner类的show()方法
		Outer o = new Outer();
		o.method();
	}
}

匿名内部类
就是内部类的简化写法 前提：存在一个类（可以是具体类也可以是抽象类）或者接口
格式： new 类名或者接口名() {重写方法;}
本质：是一个继承了类或者实现了接口的子类匿名对象

interface Inter {
	public abstract void show();
	public abstract void show2();
}

class Outer {
	public void method() {
        //接口的子类匿名对象
		Inter i = new Inter() { //多态
			public void show() {
				System.out.println("show");
			}
			
			public void show2() {
				System.out.println("show2");
			}
		};
		i.show();
		i.show2();
	}
}

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

匿名内部类在开发中的应用：（用完之后就是垃圾，不占内存）

//普通实现
Person p = new Student();
pd.method(p);

//匿名内部类实现
pd.method(new Person(){
    public void study(){
        System.out.println("好好学习");
    }
});