1.什麼是內部私有類？
在一個java類裏創建一個private的class；
2.內部私有類的功能：
在大部分的java編碼中，我們的編碼都是依賴於class的，但內部類可以實現無依賴類型編碼；
對外部而言，可以完全隱藏實現的細節；
3.具體實現：
1）定義接口（爲內部類方法的訪問做準備）：
package think.ten;
public interface Contents {
int getValue();
void setValue(int i);
}
2）定義內部類
package think.ten.impl;
public class par {
private int i;
public int getI() {
return i;
}
public void setI(int i) {
this.i = i;
}
public void pri(){
System.out.println("I'm par!");
}
}
package think.ten;
import think.ten.impl.par;
public class InnerClass {
/**
* 因爲內部私有類只能被其外圍類使用，所以其定義是不可以具體實現的，也就是不可以對外進行實例化，只能由其外部對象使用相應方法進行完成
* 但爲了能夠使用內部實現的具體方法，可以使用接口嫁接模式，用一個公共接口來作爲返回對象,調用其方法，
* 也可以使用繼承某個類，或者抽象類來實現。總之就是爲了能使內部類的外圍類對象在實例化完內部私有類之後有個接受的調用容器；
* @author Administrator
*使用內部類可以完全組織任何依賴於類型的編碼，並且達到完全隱藏實現細節的功能
*
*/
private class PCotents extends par implements Contents{
private int i=0;
@Override
public void setValue(int i){ this.i=i;}
@Override
public int getValue() {
return i;
}
}
public Contents getPc(){
return new PCotents();
}
public par getPc1(){
return new PCotents();
}
}
上述代碼中的繼承par說是作爲一個調用容器，但一般需要經過方法的Override來實現，使用抽象類繼承是一種更好的方案。
3）方法調用展示：
package think.ten.impl;
import think.ten.Contents;
import think.ten.InnerClass;
public class shixian {
public static void main(String[] args){
InnerClass in =new InnerClass();
Contents s=in.getPc();
par p=in.getPc1();
s.setValue(2);
System.out.println(s.getValue());
System.out.println(p.getI());
p.pri();
}
}
通過本節學習，和IOC中實現依賴與抽象作比較發現，內部類方法的調用也是通過抽象調用來進行的。只是將類的實例化交由內部類來實現。
內部類的優點：
1.封裝性強，可以不讓外界知道其名字；
2.可以使用外部類的變量；outClass.this 用來屏蔽內部類和外部相同的變量名
3.內部類可以是靜態的，但非靜態內部類中不可以有靜態變量和靜態方法
4.內部類是局部的，它可以定義在一個方法或者一段代碼塊內；
5.匿名內部類的使用：
public content1 getContent(){
return new content1(){
private int i=0;
public int getValue(){
return this.i;
}
}
}
6.java內部類加上接口可以實現多重繼承；示例代碼：
package com.learn.unit;
public class InnerClass {
public static void main(String[] args){
InnerTest tmp=new InnerTest(14,"楊鐵心");
//tmp.getInner().getTotalAge();//類方法的調用是依賴於對象
TotalAge tmp2=tmp.getInner();//接口接受返回方法
tmp2.getTotalAge();
tmp2.printAge();
}
}
class InnerTest extends Parent1 {
InnerTest(int age,String name){
super(age,name);
}
private class MyInner extends Parent2 implements TotalAge{
MyInner(int age,String name){
super(age,name);
}
@Override
public int getTotalAge() {
// TODO Auto-generated method stub
return super.getAge2()+getAge1();
}
@Override
public void printAge() {
// TODO Auto-generated method stub
System.out.println("age1:"+getAge1()+" age2:"+super.getAge2());
}
}
public MyInner getInner(){
return new MyInner(13, "歐陽鋒");
}
}
interface TotalAge{
int getTotalAge();
void printAge();
}
class Parent1{
private int age1;
private String name1;
Parent1(int age1,String name1){
this.age1=age1;
this.name1=name1;
};
public int getAge1() {
return age1;
}
public void setAge1(int age1) {
this.age1 = age1;
}
public String getName1() {
return name1;
}
public void setName1(String name1) {
this.name1 = name1;
}
}
class Parent2{
private int age2;
private String name2;
Parent2(int age2,String name2){
this.age2=age2;
this.name2=name2;
}
public int getAge2() {
return age2;
}
public void setAge2(int age2) {
this.age2 = age2;
}
public String getName2() {
return name2;
}
public void setName2(String name2) {
this.name2 = name2;
}
}
package inner_double_extends;
public class InnerDoubleExtends {
public static void main(String[] args){
c c=new c();
c.satAll();
}
}
/**
* 內部類實現雙重繼承
* <p>Title: </p>
* <p>Description: </p>
* <p>Company: </p>
* @author
* @date
*/
class a{
public void sayA(){
System.out.println("I'm a!");
}
}
class b{
public void sayB(){
System.out.println("I'm b!");
}
}
class c extends a{
private class inner extends b{
public void tt(){
sayA();
super.sayB();
}
};
public void sayA(){
super.sayA();
}
public void satAll(){
new inner().tt();
}
}