八、访问控制权限、内部类、异常
1、访问级别修饰符：
java访问级别修饰符主要包括：private、protected、public 用以限定其他类对该类、属性、和方法的使用权限
权限的大小排序：
小 private<default<protected<public 大
1) private 只能在本类中访问
2) default 默认的意思，但是不用写出来(省略) 可以在本类中使用 (同一个包下，不同包下不行)
3) protected 可以在本类任何位置访问(同一个包下,不同包下不行), 但是子类中可以。(也就是说你把另外一个包中的相关类给导入进去以后也是无法访问protected)
4) public
2、内部类-->重要作用：可以访问外部内中私有的数据
1）成员内部类
1.成员内部类可以等同看做成员变量
2.成员内部类不能有静态声明(静态变量和静态方法)，否则会报错
3.成员内部类可以访问外部内所有的数据
public class OutClass02 {
public static void main(String[] args){
OutClass02 oc=new OutClass02();
InnerClass ic2= oc.new InnerClass();
ic2.method2_1();
}
private static int sno1=12;
private static void method1_1(){
System.out.println("OutClass类中的静态方法执行");
}
private int sage1=14;
private void method1_2(){
System.out.println("OutClass类中的成员方法执行");
}
//成员内部类
class InnerClass{
//成员内部类中不能有静态声明(静态变量和静态方法),否则编译无法通过
private int sage2=20;
private void method2_1(){
System.out.println("InnerClass类中的成员方法执行");
System.out.println(sno1);//成员内部类可以外部所有数据(静态/成员 变量、方法)
System.out.println(sage1);
method1_1();
method1_2();
}
}
}
2）静态内部类
1.静态内部类可以等同看做静态变量
2.静态内部类可以直接访问外部类的静态数据（静态变量和静态方法），无法直接访问成员（成员变量和成员方法）。
也就是说静态内部类中的静态方法和成员方法都可以直接访问外部类的静态数据（静态变量和静态方法），无法直接访问成员（成员变量和成员方法）
静态内部类中的成员方法如何访问：InnerClass ic=new OutClass.InnerClass(); ic.m1();
public class OutClass {
public static void main(String[] args){
InnerClass ic= new OutClass.InnerClass();
ic.method2_2();
InnerClass.method2_1();
}
//静态变量
private static int sno1=12;
//静态方法
private static void method1_1(){
System.out.println("OutClass类中的静态方法执行");
}
//成员变量
private int sage1=12;
//成员方法
private void method1_2(){
System.out.println("OutClass类中的成员方法执行");
}
//静态内部类
static class InnerClass{
//静态变量
private static int sno2=18;
//静态方法
public static void method2_1(){
System.out.println("InnerClass类中的静态方法执行");
System.out.println(sno1);//静态内部类可以访问静态方法
//System.out.println(sage1);静态内部类无法访问成员变量
method1_1();//静态内部类可以访问静态方法
//method1_2();静态内部类无法访问成员方法
}
//成员变量
private int sage2=20;
//成员方法
private void method2_2(){
System.out.println("InnerClass类中的成员方法执行");
System.out.println(sno1);//静态内部类可以访问静态方法
//System.out.println(sage1);静态内部类无法访问成员变量
method1_1();//静态内部类可以访问静态方法
//method1_2();静态内部类无法访问成员方法
}
}
}
3）局部内部类
1.局部内部类等同于局部变量（存在于方法中）
重点：局部内部类在访问局部变量的时候，局部变量必须使用final修饰，意思是说局部变量只能有一个值不能有其他的值。
局部内部类中不能有静态声明，成员类不类中也不能有静态声明。局部变量只在包含该局部变量所在的方法中有效，出了该方法就不认识了。
public class OutClass03 {
public static void main(String[] args){
OutClass03 oc=new OutClass03();
oc.method();
}
public void method(){
//局部变量
int no=10;
//局部内部类中不能有静态声明,否则编译无法通过
class InnerClass{
final int i=10;
public void m2(){
System.out.println(i);
}
}
InnerClass ic=new InnerClass();
ic.m2();
}
}
4）匿名内部类
指的是类没有名字，优点是：少定义一个类，缺点是：无法重复利用
public interface CustomerService {
public void login();
}
public class CustomerServiceImpl implements CustomerService {
@Override
public void login() {
System.out.println("系统已经安全登录");
}
}
public class Test03 {
//静态方法
public static void test(CustomerService cs){
cs.login();
}
public static void main(String[] args) {
/*方法一：
通过调用接口的实现类进行实现
CustomerServiceImpl csi=new CustomerServiceImpl();
csi.login();
*/
//方法二：将匿名内部类做为一个类通过多态的方式进行调用
test(new CustomerServiceImpl(){
public void login(){
System.out.println("系统已经安全登录");
}
});
}
}
//整个这个“new CustomerService() {}”就是个匿名内部类
3、类与类之间的关系
1）泛化关系：类与类之间的继承关系 及 接口与接口之间的继承关系
public class B extends A;public interface D extends C
2）实现关系：类与接口的实现
public class B implements A
3）关联关系：类与类之间的连接，一个类可以知道另一个类的属性和方法，在Java语言中使用实例变量体现
4）聚合关系：是关联关系的一种，是较强的关联关系，是整体和部分的关系，如;汽车和轮胎，它与关联关系不同，关联关系的类处在同一个层次上
而聚合关系的类处在不相等的层次上，一个代表整体，一个代表部分，在Java语言中使用实例变量的体现。
5）合成关系：是关系的一种，比聚合关系强的关联关系，如，人和四肢，整体对象决定部分对象的生命周期，部分对象每一时刻只与一个对象发生合成关系，在java语言中使用实例变量体现。
6）依赖关系是比关联关系弱的关系，在java语言中体现为返回值，参数，局部变量和静态方法调用
|关联关系示例：|
public class Me {
String name;
String add;
Friend f;
Me(Friend f){
this.f=f;
}
}
public class Friend {
int telno;
String name;
String add;
public Friend (int telno,String name,String add){
this.telno=telno;
this.name=name;
this.add=add;
}
}
public class Test04 {
public static void main(String[] args) {
Friend f1=new Friend(12,"zhangsan","北京朝阳区");
Me m1=new Me(f1);
System.out.println(m1.f.add);//通过我的Friend属性就可以获取到Friend.add属性
}
}
|聚合关系的示例：|
public class ClassRoom{
//ClassRoom和List集合属于关联关系，在同一个层级上
//ClassRoom和Student属于聚合关系，一个是整体，一个是部分
List<Student> stus;//Student就是部分
//聚合关系:整体不依赖部分，部分也不会依赖整体，整体无法决定部分的生命周期
}
|合成关系示例：|
public class 人{
//人和List 是关联关系
//人和四肢是合成关系，人是整体，四肢是部分
//合成关系和聚合关系是相似的，区别的地方在：整体和部分是紧密相连的
//整体的声明周期决定部分的生命周期。
List<四肢> s;
}
public class 四肢{
}
|依赖关系示例：|
public class Test{
public void m1(){
//局部变量
User u= new User();//依赖关系通常体现在返回值，参数，局部变量和静态方法的调用上面。
}
}
class User{}
4、异常机制
1）异常：模拟的是现实世界中“不正常”事件，java中类去模拟异常
异常机制的作用：
当程序发生异常后，会为我们提供了详细的信息，程序员通过这个信息，可以对程序进行一些处理，使程序更加健壮。
语法1：//try...catch中最多执行一个catch语句块，执行结束之后，try...catch...语句就结束了
try{
可能出现异常的代码;
}catch(OneExcetption e){//catch语句块可以写多个
处理异常的代码;
}catch(TwoExcetption e){//从上到下的catch，必须从小类型异常到大类型异常进行捕捉
处理异常的代码;
}...
语法2：
try{
可能出现异常的代码;
}catch(OneExcetption e){
处理异常的代码;
}catch(TwoExcetption e){
处理异常的代码;
}finally{
代码;//finally语句块中的代码是一定会执行的，但是要是在执行finally语句块之前退出了jvm（System.exit(0);），则finally语句块不会执行
}
分类：
1）编译时异常，直接继承Exception
2）运行时异常，直接继承RuntimeException
|定义运行时异常：示例|
public class IllegalNameException extends RuntimeException {
IllegalNameException(){}
IllegalNameException(String msg){
System.out.println(msg);
}
}
public class NameCustomerService {
public void register(String name) throws IllegalNameException{
if(name.length()<6){
IllegalNameException e=new IllegalNameException("用户的长度不能小于6位");
throw e;
}
System.out.println("注册成功！");
}
}
public class Test05 {
public static void main(String[] args){
NameCustomerService ncs=new NameCustomerService();
String username="王五福彩";
System.out.println(username.length());
try{
ncs.register(username);
}catch(IllegalNameException e){
throw e;
}
}
}
浙公网安备 33010602011771号