复习包、权限修饰符和内部类

最新推荐文章于 2023-02-26 12:13:25 发布

如你所是

最新推荐文章于 2023-02-26 12:13:25 发布

阅读量160

点赞数

本文链接：https://blog.csdn.net/lamoura/article/details/104720565

版权

package关键字的概述及作用

1.为什么要有包?
	* 将字节码(.class)进行分类存放 
	* 包其实就是文件夹
2.定义包的格式
	* package 包名;
	* 多级包用.分开即可,这里的.其实就是路径分隔符
3.定义包的注意事项
	* A:package语句必须是程序的第一条可执行的代码
	* B:package语句在一个java文件中只能有一个
	* C:如果没有package，默认表示无包名.我们用包的时候就是为了管理更方便
4.如何编译运行带包的类
* a:javac编译的时候带上-d即可,这里的d是directory:目录
	* javac -d . HelloWorld.java             (.:代表的是当前路径,也可以指定为d盘,f盘之类的)
* b:通过java命令执行。
	* java 包名.HellWord(类名)

import关键字的概述和使用

1.为什么要有import?
	* 其实就是让有包的类对调用者可见,不用写全类名了 
2.导包格式
	* import 包名;
	* 注意：
		* 导包其实就是导入包中的某个类
		* 这种方式导入是到类的名称。
		* 虽然可以最后写*(通配符)，但是不建议。因为这样导入效率太低
3.package,import,class有没有顺序关系(面试题)
	* 有顺序关系:package必须放在第一行可执行语句,import在中间,class在后面
	* 注意package在一个类中只能有一句,而import可以有很多句

package com.yy;
import com.baidu.Person;
import com.xxx.Student;
//import java.util.Scanner;		//在开发中我们用的都是导入具体的类,这样效率高
import java.util.*;				//*代表通配符,他会到该包下挨个匹配,匹配上就导入
class Demo1_Package {
	public static void main(String[] args) {
		System.out.println("HelloWorld");
	}
}

四种访问权限修饰符

	本类	同一个包下(子类和无关类)	不同包下(子类)	不同包下(无关类)
private	Y(可以在本类中访问)
默认(默认指前面不加修饰符)	Y	Y
protected	Y	Y	Y
public	Y	Y	Y	Y

类及其组成所使用的常见修饰符

 A:修饰符：
	* 权限修饰符：private，默认的，protected，public
	* 状态修饰符：static，final
	* 抽象修饰符：abstract

 B:类：
	* 权限修饰符：默认修饰符，public
	* 状态修饰符：final(final修饰类,这个类就为最终类,不能被继承)
	* 抽象修饰符：abstract(这个类就变为抽象类)
	* 用的最多的就是：public
	
 C:成员变量：
	* 权限修饰符：private，默认的，protected，public
	* 状态修饰符：static(加静态变为静态成员变量,静态成员变量可以被直接访问而不实例化自身再访问)，final(加final变为常量)
	* 用的最多的就是：private
	
D:构造方法：
	* 权限修饰符：private，默认的，protected，public
	* 构造方法private私有的话,就不让别的类创建本类对象,当一个类中所有的方法都是静态的时候,我们就会私有其构造方法
	* 用的最多的就是：public
	
E:成员方法：
	* 权限修饰符：private，默认的，protected，public
	* 状态修饰符：static，final(加final变为最终成员方法,不能被重写)
	* 抽象修饰符：abstract
	* 用的最多的就是：public
	
F:除此以外的组合规则：
	* 成员变量：public static final(变为公共的静态的常量)
	* 成员方法：
		* public static 
	    * public abstract
		* public final

内部类

成员内部类概述
成员内部类——就是位于外部类成员位置的类
A:内部类访问特点
	* a:内部类可以直接访问外部类的成员变量和成员方法，包括私有。
	* b:外部类要访问内部类的成员，必须创建对象。
	* 外部类名.内部类名 对象名 = 外部类对象.内部类对象;

class Demo1_InnerClass {
	public static void main(String[] args) {
		//Inner i = new Inner();  //这里出错了
		//i.method();
		//外部类名.内部类名 = 外部类对象.内部类对象
		Outer.Inner oi = new Outer().new Inner();			//创建内部类对象
		oi.method();

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

当成员内部类私有时该怎样去调用内部类中的方法

class Demo2_InnerClass {
	public static void main(String[] args) {
		//Outer.Inner oi = new Outer().new Inner();
		//oi.method();                       //这种访问方式已经不可以了,因为内部类已经私有了
		//此时需要在外部类outer类中创建一个方法,提供公共的访问方式,如print方法

		Outer o = new Outer();
		o.print();
	}
}

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

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

静态成员内部类

static
成员内部类被静态修饰后的访问方式是:
	* 外部类名.内部类名 对象名 = 外部类名.内部类对象;

class Demo1_InnerClass {
	public static void main(String[] args) {
		//外部类名.内部类名 对象名 = 外部类名.内部类对象;
		Outer.Inner oi = new Outer.Inner();//= Outer.new Inner();注意这里是内部类对象,静态方法一般用类名来调用,所以不需要创建外部类对象
		oi.method();

		Outer.Inner2.print();//注意第二个静态类中有个静态方法,所以一路类名.来调用print方法
	}
}

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

	static class Inner2 {
		public static void print() {
			System.out.println("print");
		}
	}
}

面试题

面试题
要求：使用已知的变量，在控制台输出30，20，10。
class InnerClassTest {
	public static void main(String[] args) {
		Outer.Inner oi = new Outer().new Inner();
		oi.show();
	}	
}
class Outer {
	public int num = 10;
	class Inner {
		public int num = 20;
		public void show() {
			int num = 30;
			System.out.println(?);		//num;这里填num,就近原则,为30
			System.out.println(??);		//this.num;20属于内部类的成员变量,用this来调用
			System.out.println(???);	//Outer.this.num;拿到outer下面的成员变量10
			内部类之所以能获取到外部类的成员,是因为他能获取到外部类的引用:外部类名.this
		}
	}
}

局部内部类

局部内部类——就是定义在一个方法或者一个作用域里面的类
特点：主要是作用域发生了变化，只能在自身所在方法和属性中被使用

局部内部类创建对象

class Demo1_InnerClass {
	public static void main(String[] args) {
		Outer o = new Outer();
		o.method();
	}
}
//局部内部类
class Outer {
	public void method() {
		final int num = 10;//num进常量池,延长int num的生命周期
		class Inner {
			public void print() {
				System.out.println(num);
			}
		}

		Inner i = new Inner();
		i.print();
	}

	/*public void run() {
		Inner i = new Inner();				//局部内部类,只能在其所在的方法中访问
		i.print();
	}*/
}
局部内部类访问局部变量的问题
在上述程序中局部内部类访问局部变量必须用final修饰
而局部内部类在访问他所在方法中的局部变量必须用final修饰,为什么?
	因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,
	当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,
	如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用
	但是jdk1.8取消了这个事情,可能是个bug

匿名内部类

A:匿名内部类
	* 就是内部类的简化写法。是局部内部类的一种,所以匿名内部类必须写在方法里.
B:前提：存在一个类或者接口
	* 这里的类可以是具体类也可以是抽象类。
C:格式：
		new 类名或者接口名(){
			重写方法;
		}
D:本质是什么呢?
	* 是一个继承了该类或者实现了该接口的子类匿名对象。
F:注意
	* 匿名内部类只针对重写一个方法时候使用,有多个方法时使用有名字的内部类.

案例演示

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

class Outer {
	/*class Inner implements Inter {    //这里是有名字的局部内部类继承接口的调用
		public void print() {
			System.out.println("print");
		}
	}*/

	public void method(){
		//Inner i = new Inner();
		//i.print();                  //上面+这行 为局部内部类的对象调用方法
		//new Inner().print();        //上面两行的缩写
		
		new Inter() {						//实现Inter接口
			public void print() {			//重写抽象方法
				System.out.println("print");
			}
		}.print();                         //new Inter后面这一大块到.就相当于Inter的子类对象;.print();相当于调用子类对象里面的print方法.
	}
}
/*new Inter() {						
			public void print() {			
				System.out.println("print");
			}
		};
/*整个这一块代表的是Inter接口的子类对象,记得加分号;

再来个简洁版的匿名内部类

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

interface Inner {
    public abstract void show();
}

class Outer {
    public void method(){
        new Inner() {
            public void show() {
                System.out.println("HelloWorld");
            }
        }.show();
    }
}

当匿名内部类中有多个方法时如何调用

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

interface Inter {
	public void show1();
	public void show2();
}
class Outer {
	public void method() {
		Inter i = new Inter(){ 			//多态，父类引用指向子类对象;因为new Inner(){}代表的是接口的子类对象
				public void show1() {
					System.out.println("show1");
				}
	
				public void show2() {
					System.out.println("show2");
				}
		};
		i.show1();
		i.show2();
		}
}

匿名内部类在开发中的使用

我们在开发的时候，会看到抽象类，或者接口作为参数.
而这个时候，实际需要的是一个子类对象.如果该方法仅仅调用一次，我们就可以使用匿名内部类的格式简化,代码如下:

class PersonTest {
	public static void main(String[] args) {
		//如何调用PersonDemo中的method方法呢?
		PersonDemo pd = new PersonDemo ();
		pd.method(new Person() {    		//匿名内部类当做参数传递,本质把匿名内部类看作一个对象
			public void show() {
				System.out.println("show");
			}
		});
	}
}
abstract class Person {
	public abstract void show();
}

class PersonDemo {
	/*
	Person p = new Person(){
		public void show() {
			System.out.println("show");
		}
	};  //这里并不是抽象类创建子类对象,而是父类引用指向子类对象,new person(){}属于特定写法;在调用的时候是把整个的对象赋值给p了,编译看父类,运行看子类
	*/
	public void method(Person p) {
		p.show();
	}
}

面试题

		按照要求，补齐代码
		class OuterDemo {
			public static void main(String[] args) {
				  Outer.method().show();
			  }
		}
		interface Inter { void show(); }
		class Outer { //补齐代码 }
		
		要求在控制台输出”HelloWorld”
答:
class OuterDemo {
	public static void main(String[] args) {
	  	Outer.method().show(); //这里用类调用方法,说明方法是静态的;链式编程,每次调用方法后还能继续调用方法,证明调用完方法Outer.method()返回的是对象,
	  	//而且Outer.method()能调用show方法,说明Outer.method()返回的是Inter对象(Inter是接口,返回它的对象又没有意义)或者是Inter的子类对象,这里一定返回的就是Inter的子类对象
	 	}
	}
	interface Inter { 
		void show(); 
	}
	class Outer { 
		public static Inter method(){
			return new Inter() {
				public void show() {
					System.out.println("HelloWorld");
			}
		};
	}
}