2019-05-30 java学习日记
面向对象
四种权限修饰符
1,其中private的权限最小,只能在本类中访问
2,其次是默认,类名,构造方法前什么都不打,
可以在本类中和同一个包下(子类和无关类)中访问
3,然后是protected,可以在可以在本类,
同一个包下(子类和无关类),不同包下的子类中访问
4,最后是public,public的访问权限最大,
可以在可以在本类,同一个包下(子类和无关类),
不同包下的子类与不同包下的无关系类中访问
类及其组成所使用的常见修饰符
修饰符
权限修饰符:private,默认的,protected,public
状态修饰符:static,final
抽象修饰符:abstract
类
权限修饰符:默认修饰符,public
状态修饰符:final
抽象修饰符:abstract
用的最多的是:private
成员变量
权限修饰符: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
内部类的概述
在类中定义类,这就是叫做内部类
内部类的访问特点
1,内部类可以直接访问外部类的成员,包括私有
2,外部类要访问内部类的成员,必须创建对象
3,外部类名.内部类名 对象名 = 外部类对象.内部类对象;
如:Outer.Inter oi = new Outer().new Inter();
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 class demo1_innerclass { 2 public static void main (String args []) { 3 //外部类访问内部类时一定要创建对象 4 outer.inner oi=new outer().new inner(); 5 oi.method(); 6 } 7 } 8 class outer { 9 private int num=20; 10 class inner { //内部类可以直接访问外部类 11 public void method() { 12 System.out.println(num); 13 } 14 } 15 }
成员内部类私有使用
class Demo_Inner { public static void main(String[] args) {
Outer o = new Outer(); o.method(); } } class Outer { private int numb = 20; private class Inner { public void print() { System.out.println(numb); } } public void method() { Inner i = new Inner(); i.print(); } }
内部类私有,在外部类创建一方法,在方法里创建一个对象进行调用。
注://outer.inner oi=new outer().new inner();
//oi.method();
这种情况下就不能使用这种方法
静态成员内部类
1 class demo2_Inner { 2 public static void main (String args []) { 3 //外部类名.内部类名 对象名 = 外部类名.内部类对象 4 Outer.Inner oi = new Outer.Inner(); 5 oi.method(); 6 7 Outer.Inner2.print(); 8 } 9 } 10 class Outer { 11 static class Inner { 12 public void method() { 13 System.out.println("啦啦啦"); 14 } 15 } 16 static class Inner2{ 17 public static void print(){ 18 System.out.println("哇哈哈"); 19 } 20 } 21 }
注:Outer.Inner oi = new Outer.Inner();
其次是外部类名. new内部类名,
只是我们习惯把new放在最前面,
所以是 new Outer.Inner();
局部内部类
1 class demo1_Innerclass { 2 public static void main (String args []) { 3 Outer o = new Outer(); 4 O.print(); 5 } 6 } 7 class Outer {
final int a = 10; 8 public void print() { 9 class Inner{ 10 public void method() { 11 System.out.println("喵喵喵?"); 12 } 13 } 14 Inner i = new Inner(); 15 I.method(); 16 } 17 }
注:局部内部类只能在本类方法去访问,运行完就会被弹栈,
所以局部内部类在访问他所在的方法中的局部变量必须用final修饰,使其变为常量,
方法弹栈后,常量会存在方法区的常量池
为什么局部内部类在访问他所在方法中的局部变量必须用final修饰?
因为当调用这个方法时,局部变量如果没有用final修饰,
他的生命周期和方法的生命周期是一样的,当方法弹栈,
这个局部变量也会消失,那么如果局部内部类对象还没有马
上消失想用这个局部变量,就没有了,如果用final修饰会在类加载
的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用
注:但是jdk1.8取消了这个事情,所以我认为这是个bug,虽然取消,
但是如果在书写代码的时候,没有手动添加,系统底层也会默认给你final
匿名内部类就是内部类的简化写法(没有名字的内部类)
前提:必须存在在一个类或者接口
这里的类视具体类也可以是抽象类
格式
new 类名或者接口名(){
重写方法:
}
new一个类 ,就代表是继承这个接口,
而new一个接口,那就是实现这个接口
本质就是一个继承了该类或者实现了该接口的子类匿名对象
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 class Demo_NoNameInner { 2 public static void main(String[] args) { 3 Outer o = new Outer(); 4 o.method(); 5 } 6 } 7 8 interface Inter { 9 public void print(); 10 } 11 12 class Outer { 13 class Inner implements Inter { 14 public void print() { 15 System.out.println("哇哈哈"); 16 } 17 } 18 19 public void method() { 20 new Inner().print(); //这个其实跟以下的整一块差不多 21 new Inter() { //实现Inter接口 22 public void print() { //重写抽象方法 23 System.out.println("喵喵喵"); 24 } 25 }.print(); //调用子类对象里面的方法 26 //这一块整个代表Inter的子类对象 27 28 } 29 30 }