目录
1.final关键字
2.四种权限修饰符
3.内部类
（1）定义：一个类内部包含另一个类
（2）使用
（3）内部类重名变量
（4）匿名内部类
（5）类作为成员变量
1.final关键字
final关键字
1.修饰一个类
public final class myclass(){//当前这个类不能有任何的子类
}
tip：一个类如果是final，其中所有的成员方法都无法进行覆盖重写
2.修饰一个方法
这个方法就是最终方法，不能被覆盖重写
public final void method(){}
tip:对于类还有方法来说，abstract关键字和final不能同时使用，因为矛盾；
abstact没有方法体，子类一定要覆盖重写方法，但是final不能被覆盖重写
3.修饰一个局部变量
final int num = 200;//使用final，不能改变局部变量，一次赋值不能更改，即使 num = 200;
final int num3;
num3 = 1;//只要保证有唯一一次赋值即可
//不可变，基本类型指的是变量当中的数据不可改变
//引用类型指的是变量当中的地址值不可改变，但是地址值中的对象可以改变
final student stu = new student("name");
stu.setname("name2");//可以变
4.修饰一个成员变量
1.由于成员变量具有默认值，所以用了final之后必须手动赋值，不会给默认值了;
2.对于final，要么直接赋值，要么构造方法赋值：
private final string name = "abc";
2.四种权限修饰符
public > protected > (default) > private
同一个类：YES YES YES YES
同一个包：YES YES YES NO
不同包的子类：YES YES NO NO
不同包非子类：YES NO NO NO
3.内部类
（1）定义：一个类内部包含另一个类
成员内部类局部内部类（包含匿名内部类）
（2）使用
定义：
public class body {
public class heart{//成员内部类
public void beat(){
System.out.println("heart内部类");
System.out.println(name);
}
}
private String name;
public void method(){
System.out.println("body外部类");
}
}
使用：
body类：
package cn.itcast;
public class body {
public class heart{//成员内部类
public void beat(){
System.out.println("heart内部类");
System.out.println("我叫"+name);
}
}
private String name;
public void method(){
System.out.println("body外部类");
new heart().beat();//使用内部类
}
}
main：
public class test{
public static void main(String[] args) {
//间接使用
body temp = new body();
temp.method();
//直接使用
body.heart hea = new body().new heart();
hea.beat();
}
}
（3）内部类重名变量
成员内部类：
public class body {
int num = 10;//外部类的成员变量
public class heart{//成员内部类
int num = 20;//内部类的成员变量
public void methodInner(){
int num = 30;//内部成员方法的局部变量
System.out.println(num);//局部变量
System.out.println(this.num);//内部类成员变量
System.out.println(body.this.num);//外部类的成员变量
}
}
}
使用;
public class test{
public static void main(String[] args) {
body.heart hea = new body().new heart();
hea.methodInner();
}
}
局部内部类：
public class body {
public void methodOuter(){
class Inner{//局部内部类
int num = 10;
public void methodInner(){
System.out.println(num);
}
}
Inner inner = new Inner();
inner.methodInner();
}
}
使用：
public class test{
public static void main(String[] args) {
body imp = new body();
imp.methodOuter();
}
}
如果一个类是定义在一个方法内部的，那么就是一个局部内部类
局部：只有当前所属的方法才能使用，出了这个方法就不能使用
成员修饰符：
public > protected > (default) > private
定义一个类的时候，权限修饰符规则：
1.外部类:public / (default)
2.成员内部类：public / protected / (default) / private
3.局部内部类：什么都不能写
局部内部类的final：
如果希望访问所在方法的局部变量，那么这个局部变量必须是[有效final]的
备注:从java8开始，只要局部变量不变，那么final关键字可以省略
public class body {
public void methodOuter(){
int num = 10;//所在方法的局部变量
class Inner{//局部内部类
public void methodInner(){
System.out.println(num);
}
}
}
}
原因：
1.new出来的对象在堆内存当中
2.局部变量是跟着方法走的，在栈内存当中
3.方法运行之后，立刻出栈，局部变量就会立刻消失
4.但是new出来的对象会在堆中，只至垃圾回收消失
（4）匿名内部类
如果接口的实现类只需要使用唯一的一次
那么这种情况下就可以省略掉该类的定义，而改为匿名内部类
为了只用一次的接口实现一个implements，麻烦，改用匿名内部类
interface obj = new interface{
@override
public void method(){
sout();
};
obj.method();
}
匿名内部类的注意问题：
1.匿名内部类，在创建对象的时候，只能使用唯一的一次
如果希望多次创建对象，而且类的内容一样的话，那么就必须使用单独的定义的实现类
2.匿名对象，再调用方法的时候，在调用方法的时候，只能调用唯一一次
如果希望同一个对象调用多次方法，必须给对象起名字
4.泛型
（1）定义
public class body<E> {
private E name;
public E getName(){
return name;
}
public void setName(E name){
this.name = name;
}
}
public class test{
public static void main(String[] args) {
body<Integer> b = new body<Integer>();
b.setName(1);
Integer temp = b.getName();
System.out.println(temp);
}
}
（2）含有泛型的方法
public class body{
//定义一个含有泛型的方法
public <M> void method(M m){
System.out.println(m);
}
}
public class test{
public static void main(String[] args) {
//测试含有泛型的方法
//传进去什么类型，泛型就是什么类型
body b = new body();
b.method("1");
b.method(1);
}
}
（3）含有泛型的接口
public interface jiekou<I>{
public abstract void method(I i);
}
public class jiekouShixian implements jiekou<String> {
@Override
public void method(String string) {
System.out.println(string);
}
}
public class test{
public static void main(String[] args) {
//测试含有泛型的方法
//传进去什么类型，泛型就是什么类型
jiekouShixian imp = new jiekouShixian();
imp.method("abaaac");
}
}
public interface jiekou<I>{
public abstract void method(I i);
}
public class jiekouShixian<I> implements jiekou<I> {
@Override
public void method(I i) {
System.out.println(i);
}
}
public class test{
public static void main(String[] args) {
jiekouShixian<String> imp = new jiekouShixian<>();
imp.method("adad");
}
}
（4）泛型通配符
泛型的通配符：
？:代表任意的数据类型
使用方式：
不能创建对象使用
定义的时候不能使用
只能作为方法的参数使用
public class test{
public static void main(String[] args) {
ArrayList<Integer> list1 = new ArrayList<>();
list1.add(1);
list1.add(2);
ArrayList<String> list2 = new ArrayList<>();
list2.add("adc");
list2.add("efg");
printArray(list1);
printArray(list2);
}
//使用?接收数据类型
public static void printArray(ArrayList<?> list){
//使用迭代器遍历集合
Iterator<?> it = list.iterator();
while(it.hasNext()){
Object o = it.next();
System.out.println(o);
}
}
}
