java基础之修饰符和内部类
2015-09-21 22:35
567 查看
1、java修饰符
/*
修饰符:
权限修饰符:private,默认的,protected,public
状态修饰符:static,final
抽象修饰符:abstract
2、内部类
3、总结
/*
修饰符:
权限修饰符:private,默认的,protected,public
状态修饰符:static,final
抽象修饰符:abstract
类: 权限修饰符:默认修饰符,public 状态修饰符:final 抽象修饰符:abstract 用的最多的就是:public 成员变量: 权限修饰符:private,默认的,protected,public 状态修饰符:static,final 用的最多的就是:private 构造方法: 权限修饰符:private,默认的,protected,public 用的最多的就是:public 成员方法: 权限修饰符:private,默认的,protected,public 状态修饰符:static,final 抽象修饰符:abstract 用的最多的就是:public 除此以外的组合规则: 成员变量:public static final 成员方法:public static public abstract public final
public class Demo { //成员变量 private int x = 10; int y = 20; protected int z = 30; public int a = 40; public final int b = 50; public static int c = 60; public static final int d = 70; //此处不允许使用修饰符abstract //abstract int e = 80; //构造方法 private Demo(){} Demo(String name){} protected Demo(String name,int age) {} public Demo(String name,int age,String address) {} //此处不允许使用修饰符static //public static Demo(){} //此处不允许使用修饰符final //public final Demo() {} //此处不允许使用修饰符abstract //public abstract Demo(){} //成员方法 //static void show() {} //abstract void show(); //final void show(){} }
/* 权限修饰符: 本类 同一个包下(子类和无关类) 不同包下(子类) 不同包下(无关类) private Y 默认 Y Y protected Y Y Y public Y Y Y Y */ package com.liuyi; public class Father { private void show() { System.out.println("show"); } void show2() { System.out.println("show2"); } protected void show3() { System.out.println("show3"); } public void show4() { System.out.println("show4"); } public static void main(String[] args) { Father f = new Father(); f.show(); f.show2(); f.show3(); f.show4(); } }
package com.liuyi; public class Son extends Father { public static void main(String[] args) { Father f = new Father(); //f.show(); f.show2(); f.show3(); f.show4(); System.out.println("--------------"); Son s = new Son(); //s.show(); s.show2(); s.show3(); s.show4(); } }
package cn.qx; import com.liuyi.Father; public class Son2 extends Father { public static void main(String[] args) { Father f = new Father(); //f.show(); //f.show2(); //f.show3(); f.show4(); System.out.println("--------------"); Son2 s = new Son2(); //s.show(); //s.show2(); s.show3(); s.show4(); } }
package com.liuyi; public class Test { public static void main(String[] args) { Father f = new Father(); //f.show(); f.show2(); f.show3(); f.show4(); } }
package cn.qx; import com.liuyi.Father; class Test2 { public static void main(String[] args) { Father f = new Father(); //f.show(); //f.show2(); //f.show3(); f.show4(); } }
2、内部类
/* 成员内部类的修饰符: private 为了保证数据的安全性 static 为了方便访问数据 注意:静态内部类访问的外部类数据必须用静态修饰。 案例:我有一个人(人有身体,身体内有心脏。)
class Body { private class Heart { public void operator() { System.out.println("心脏搭桥"); } } public void method() { if(如果你是外科医生) { Heart h = new Heart(); h.operator(); } } } 按照我们刚才的讲解,来使用一下 Body.Heart bh = new Body().new Heart(); bh.operator(); //加了private后,就不能被访问了,那么,怎么玩呢? Body b = new Body(); b.method(); */ class Outer { private int num = 10; private static int num2 = 100; //内部类用静态修饰是因为内部类可以看出是外部类的成员 public static class Inner { public void show() { //System.out.println(num); System.out.println(num2); } public static void show2() { //System.out.println(num); System.out.println(num2); } } } class InnerClassDemo4 { public static void main(String[] args) { //使用内部类 // 限定的新静态类 //Outer.Inner oi = new Outer().new Inner(); //oi.show(); //oi.show2(); //成员内部类被静态修饰后的访问方式是: //格式:外部类名.内部类名 对象名 = new 外部类名.内部类名(); Outer.Inner oi = new Outer.Inner(); oi.show(); oi.show2(); //show2()的另一种调用方式 Outer.Inner.show2(); } }
/* 成员内部类: 如何直接访问内部类的成员。 外部类名.内部类名 对象名 = 外部类对象.内部类对象; */ class Outer { private int num = 10; class Inner { public void show() { System.out.println(num); } } } class InnerClassDemo3 { public static void main(String[] args) { //需求:我要访问Inner类的show()方法 //Inner i = new Inner(); //i.show(); //格式:外部类名.内部类名 对象名 = 外部类对象.内部类对象; Outer.Inner oi = new Outer().new Inner(); oi.show(); } }
/* 内部类概述: 把类定义在其他类的内部,这个类就被称为内部类。 举例:在类A中定义了一个类B,类B就是内部类。 内部的访问特点: A:内部类可以直接访问外部类的成员,包括私有。 B:外部类要访问内部类的成员,必须创建对象。 */ class Outer { private int num = 10; class Inner { public void show() { System.out.println(num); } } public void method() { //找不到符号 //show(); Inner i = new Inner(); i.show(); } } class InnerClassDemo { public static void main(String[] args) { } }
/* 内部类位置 成员位置:在成员位置定义的类,被称为成员内部类。 局部位置:在局部位置定义的类,被称为局部内部类。 成员位置:在成员位置定义的类,被称为成员内部类。 */ class Outer { private int num = 10; //成员位置 /* class Inner { } */ public void method() { //局部位置 class Inner { } } } class InnerClassDemo2 { public static void main(String[] args) { } }
/* 局部内部类 A:可以直接访问外部类的成员 B:在局部位置,可以创建内部类对象,通过对象调用内部类方法,来使用局部内部类功能 面试题: 局部内部类访问局部变量的注意事项? A:局部内部类访问局部变量必须用final修饰 B:为什么呢? 局部变量是随着方法的调用而调用,随着调用完毕而消失。 而堆内存的内容并不会立即消失。所以,我们加final修饰。 加入final修饰后,这个变量就成了常量。既然是常量。你消失了。 我在内存中存储的是数据20,所以,我还是有数据在使用。 */ class Outer { private int num = 10; public void method() { //int num2 = 20; //final int num2 = 20; class Inner { public void show() { System.out.println(num); //从内部类中访问本地变量num2; 需要被声明为最终类型 System.out.println(num2);//20 } } //System.out.println(num2); Inner i = new Inner(); i.show(); } } class InnerClassDemo5 { public static void main(String[] args) { Outer o = new Outer(); o.method(); } }
/* 匿名内部类 就是内部类的简化写法。 前提:存在一个类或者接口 这里的类可以是具体类也可以是抽象类。 格式: new 类名或者接口名(){ 重写方法; } 本质是什么呢? 是一个继承了该类或者实现了该接口的子类匿名对象。 */ interface Inter { public abstract void show(); public abstract void show2(); } class Outer { public void method() { //一个方法的时候 /* new Inter() { public void show() { System.out.println("show"); } }.show(); */ //二个方法的时候 /* new Inter() { public void show() { System.out.println("show"); } public void show2() { System.out.println("show2"); } }.show(); new Inter() { public void show() { System.out.println("show"); } public void show2() { System.out.println("show2"); } }.show2(); */ //如果我是很多个方法,就很麻烦了 //那么,我们有没有改进的方案呢? Inter i = new Inter() { //多态 public void show() { System.out.println("show"); } public void show2() { System.out.println("show2"); } }; i.show(); i.show2(); } } class InnerClassDemo6 { public static void main(String[] args) { Outer o = new Outer(); o.method(); } }
/* 面试题: 要求请填空分别输出30,20,10。 注意: 1:内部类和外部类没有继承关系。 2:通过外部类名限定this对象 Outer.this */ class Outer { public int num = 10; class Inner { public int num = 20; public void show() { int num = 30; System.out.println(num); System.out.println(this.num); //System.out.println(new Outer().num); System.out.println(Outer.this.num); } } } class InnerClassTest { public static void main(String[] args) { Outer.Inner oi = new Outer().new Inner(); oi.show(); } }
/* 匿名内部类在开发中的使用 */ interface Person { public abstract void study(); } class PersonDemo { //接口名作为形式参数 //其实这里需要的不是接口,而是该接口的实现类的对象 public void method(Person p) { p.study(); } } //实现类 class Student implements Person { public void study() { System.out.println("好好学习,天天向上"); } } class InnerClassTest2 { public static void main(String[] args) { //测试 PersonDemo pd = new PersonDemo(); Person p = new Student(); pd.method(p); System.out.println("--------------------"); //匿名内部类在开发中的使用 //匿名内部类的本质是继承类或者实现了接口的子类匿名对象 pd.method(new Person(){ public void study() { System.out.println("好好学习,天天向上"); } }); } }
/* 匿名内部类面试题: 按照要求,补齐代码 interface Inter { void show(); } class Outer { //补齐代码 } class OuterDemo { public static void main(String[] args) { Outer.method().show(); } } 要求在控制台输出”HelloWorld” */ interface Inter { void show(); //public abstract } class Outer { //补齐代码 public static Inter method() { //子类对象 -- 子类匿名对象 return new Inter() { public void show() { System.out.println("HelloWorld"); } }; } } class OuterDemo { public static void main(String[] args) { Outer.method().show(); /* 1:Outer.method()可以看出method()应该是Outer中的一个静态方法。 2:Outer.method().show()可以看出method()方法的返回值是一个对象。 又由于接口Inter中有一个show()方法,所以我认为method()方法的返回值类型是一个接口。 */ } }
3、总结
4:权限修饰符(掌握) (1)权限修饰符 本类 同一个包下 不同包下的子类 不同包下的无关类 private Y 默认 Y Y protected Y Y Y public Y Y Y Y (2)这四种权限修饰符在任意时刻只能出现一种。 public class Demo {} 5:常见的修饰符(理解) (1)分类: 权限修饰符:private,默认,protected,public 状态修饰符:static,final 抽象修饰符:abstract (2)常见的类及其组成的修饰 类: 默认,public,final,abstract 常用的:public 成员变量: private,默认,protected,public,static,final 常用的:private 构造方法: private,默认,protected,public 常用的:public 成员方法: private,默认,protected,public,static,final,abstract 常用的:public (3)另外比较常见的: public static final int X = 10; public static void show() {} public final void show() {} public abstract void show(); 6:内部类(理解) (1)把类定义在另一个类的内部,该类就被称为内部类。 举例:把类B定义在类A中,类B就被称为内部类。 (2)内部类的访问规则 A:可以直接访问外部类的成员,包括私有 B:外部类要想访问内部类成员,必须创建对象 (3)内部类的分类 A:成员内部类 B:局部内部类 (4)成员内部类 A:private 为了数据的安全性 B:static 为了访问的方便性 成员内部类不是静态的: 外部类名.内部类名 对象名 = new 外部类名.new 内部类名(); 成员内部类是静态的: 外部类名.内部类名 对象名 = new 外部类名.内部类名(); (5)成员内部类的面试题(填空) 30,20,10 class Outer { public int num = 10; class Inner { public int num = 20; public viod show() { int num = 30; System.out.println(num); System.out.println(this.num); System.out.println(Outer.this.num); } } } (6)局部内部类 A:局部内部类访问局部变量必须加final修饰。 B:为什么呢? 因为局部变量使用完毕就消失,而堆内存的数据并不会立即消失。 所以,堆内存还是用该变量,而改变量已经没有了。 为了让该值还存在,就加final修饰。 通过反编译工具我们看到了,加入final后,堆内存直接存储的是值,而不是变量名。 (7)匿名内部类(掌握) A:是局部内部类的简化形式 B:前提 存在一个类或者接口 C:格式: new 类名或者接口名() { 重写方法; } D:本质: 其实是继承该类或者实现接口的子类匿名对象
相关文章推荐
- java编程思想第二章总结--一切皆对象
- 排序算法——java实现
- java的Class类
- struts2整合axis2后,访问不到wsdl,被struts2拦截的解决办法
- 重温Thinking in java
- JDK1.5新特性——Lock、Condition接
- java编程基础2
- SpringMVC与Struts2的对比
- 构造函数、、set与get方法
- Java中字符和byte数组之间的相互转换
- Android开发环境搭建——Eclipse
- maven+springMVC+mybatis 搭建资料收集
- C#/Java 调用WSDL接口及方法
- Java HashMap的死循环
- Java关键字instanceof
- 难经6:小心,SpringAOP声明式事务的一个缺陷
- 深入理解Java:内省(Introspector)
- struts2总结五: Strut2 访问Servlet API
- Java基础学习总结(二)
- 在web.xml中注册IntrospectorCleanupListener监听器以解决struts等框架可能产生的内存泄露问题