形式引數-返回值-內部類-匿名內部類
一.形式引數和返回值
1.基本資料型別:
你要什麼資料型別,實際傳參的時候就傳什麼資料型別,形式引數的改變對實際引數沒有影響(String是引用型別,但和基本型別的效果一樣String s = "luo")。 關於String:String a = "abc"和String s = new String("abc")的區別 在Java虛擬機器(JVM)中存在著一個字串池,其中儲存著很多String物件,並且可以被共享使用,因此它提高了效率。String a = "abc";在執行這個程式碼的時候,Java虛擬機器首先在字串池pool中查詢是否已經存在了“abc”的這麼一個物件,判斷依據是String類equals(Object obj)方法的返回值。如果有,則不再建立新的物件,直接返回已存在物件的引用;如果沒有,則先建立這個物件,然後把它加入到字串池中,再將它的引用返回。class Demo{ //成員方法 public int sum(int a,int b){ return (a+b); } } public class BasicDataTest { public static void main(String[] args) { Demo d = new Demo(); int result = d.sum(3, 4); //3、4是實際的兩個引數 System.out.println("result = "+result); System.out.println("-------------"); String str1 = "fly"; String str2 = "weight"; String str3 = "flyweight"; String str4 = null; str4 = str1 + str2; System.out.println(str3 == str4); //false /* * str3和str4指向同一個物件,通過intern()方法來實現,會先在字串常量池中尋找內容為“flyweight”的地址, 如果找到,就將str4變數指向這個地址,如果找不到,就將建立一個字串常量並將其加入到常量池中,此處已有這個地址, 所以str4指向這個地址。即str3和str4變數指向為同一個地址,兩個引用指向同一個字串物件。 */ str4 = (str1 + str2).intern(); System.out.println(str3 == str4); //true } }
2.引用型別:具體類、抽象類、介面
1)具體類:
形式引數:如果形式引數是一個具體的類,那麼需要建立該類物件
class Student{ public void show(){ System.out.println("好好學Java!"); } } class StudentDemo{ public void method(Student s){ //形式引數是一個引用型別,那麼需要該類物件Student s = new Student(); s.show(); } } public class ConcreteDemo { public static void main(String[] args) { //需求:呼叫StudentDemo中的method()方法,則需要建立StudentDemo這個類的物件 StudentDemo sd = new StudentDemo(); //建立Student類的物件 Student s = new Student(); sd.method(s); //s代表Student類的物件,把空間地址值作為引數傳遞 } }
返回值:方法的返回值是一個具體的類,那麼需要建立該類物件
class Student{
public void show(){
System.out.println("好好學Java!");
}
}
class StudentDemo{ //如果方法的返回值是一個具體的類,那麼需要該類的物件
public Student method(){
/*
Student s = new Student();
return s;
*/
return new Student(); //匿名物件
}
}
public class ConcreteDemo {
public static void main(String[] args) {
//需求:呼叫StudentDemo中的method()方法,則需要建立StudentDemo這個類的物件
StudentDemo sd = new StudentDemo();
Student s = sd.method(); //返回的是一個Student型別的物件
s.show(); //再呼叫Student類中的show()方法
}
}
2)抽象類:
形式引數:需要再定義一個抽象類的子類,來進行例項化(建立物件!)建立物件的實質:抽象類多型!
//宣告一個抽象類
abstract class Person{
public abstract void study();
}
//定義一個PersonDemo類
class PersonDemo{
//定義一個帶有形參的成員方法
public void method(Person p){ //Person p = new Person()是錯誤的,因為抽象類不能例項化,
//需要再宣告一個抽象類的子類,通過抽象類多型例項化
p.study();
}
}
//宣告抽象類的子類
class Person2 extends Person{
//重寫抽象類中的抽象方法
public void study(){
System.out.println("好好學Java!");
}
}
//測試類
public class AbstractDemo {
public static void main(String[] args) {
//呼叫PersonDemo中的method()方法;
PersonDemo pd = new PersonDemo();
//需要使用抽象類多型實現化
Person p = new Person2();
pd.method(p);
/*//鏈式程式設計:
new PersonDemo().method(new Person2());
*/
}
}
返回值:返回值如果是抽象類,需要返回的是該抽象類的子類物件
//宣告一個抽象類
abstract class Person3{
public abstract void show();
}
//定義PersonDemo2類
class PersonDemo2{
public Person3 method(){ //如果一個方法的返回值是一個抽象類,需要返回的是該抽象類的子類物件
Person3 p = new Person4();
return p;
//return new Person4();
}
}
//抽象類的子類
class Person4 extends Person3{
public void show(){
System.out.println("愛學習!愛Java!");
}
}
//測試類
public class ReturnAbstract {
public static void main(String[] args) {
//呼叫PersonDemo2中的method()方法
PersonDemo2 pd = new PersonDemo2();
Person3 p3 = pd.method(); //返回的是Person3的物件
p3.show();
System.out.println("---------");
/*
//鏈式程式設計
Person3 p3 = new PersonDemo2().method();
p3.show();
*/
}
}
3)介面
形式引數:如果形式引數是介面的情況,那麼需要自定義一個介面的子實現類,然後通過介面多型的形式給介面例項化!
//介面
interface Inter{
public abstract void love();
}
class TeacherDemo{
public void method(Inter i){ //介面不能例項化;如果一個方法的形式引數是一個介面,那麼需要建立該介面的子實現類物件
i.love();
}
}
//介面不能例項化,需要定義介面的子實現類
class Teacher implements Inter{
public void love(){
System.out.println("teacher love Java!");
}
}
//測試類
public class InterfaceDemo {
public static void main(String[] args) {
//呼叫TeacherDemo中的method()方法
TeacherDemo td = new TeacherDemo();
//建立該介面物件:通過介面多型
//Inter i = new Teacher();
//匿名內部類
Inter i = new Inter(){
public void love(){
System.out.println("teacher love Java!");
}
};
td.method(i);
}
}
返回值:返回值如果是介面型別,需要返回的是該介面子實現類物件(通過子實現類進行例項化!)
//定義介面
interface Inter2{
public abstract void love();
}
//定義一個返回值是介面的類
class TeacherDemo2{ //如果一個方法的返回值是介面型別,需要返回該介面對應的子實現類的物件
public Inter2 method(){
Inter2 i = new Teacher2();
return i;
//return new Teacher2();
}
}
//介面的子實現類
class Teacher2 implements Inter2{
public void love(){
System.out.println("teacher love Java!");
}
}
//測試類
public class ReturnInterface {
public static void main(String[] args) {
TeacherDemo2 td = new TeacherDemo2();
Inter2 inter2 = td.method();
inter2.love();
}
}
二.內部類
1.概念:在一個類中定義另一個類,稱為內部類。
eg:在類A中定義一個類B,那麼類B是類A的內部類,同理,類A就是類B的外部類。內部類是直接可以訪問外部類的成員,包括私有。外部類要訪問內部類的成員,必須通過建立內部類的物件訪問該內部類的成員。
class Outer{
//外部類的成員變數
public int num = 10;
private int num1 = 20;
//內部類
class Inner{
//內部類的成員方法
public void show(){
//內部類可以直接訪問外部類的成員,包括私有
System.out.println("num = "+num);
System.out.println("num1 = "+num1);
}
}
//外部類的成員方法
public void method(){
//外部類不能直接訪問內部類,必須建立內部類的物件
Inner i = new Inner();
i.show();
}
}
//測試類
public class InnerDemo {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
2.內部類的分類:成員內部類、區域性內部類
package day_09_10_24;
//外部類
class Outer{
//外部類的成員變數
public int num = 12;
//成員內部類
class Inner{
}
//外部類的成員方法
public void method(){
//區域性內部類
class Inner2{
}
}
}
//測試類
public class InnerClass {
public static void main(String[] args) {
}
}
1)成員內部類:在外部類的成員位置,測試類中需要訪問成員內部類中的成員方法:外部類名.內部類名 物件名 = 外部類物件.內部類物件;
package day_09_10_24;
//外部類
class Outer3{
//定義外部類的變數
public int num = 10;
//成員內部類(非靜態成員內部類)
class Inner3{
//內部類的成員方法(非靜態的成員方法)
public void show(){
System.out.println("num = "+num);
}
}
//外部類的成員方法
public void method(){
}
}
//測試類
public class MemberInner {
public static void main(String[] args) {
/**
* 需求:訪問Inner3成員內部類中的show()方法
* 外部類名.內部類名 物件名 = 外部類物件.內部類物件;
*/
Outer3.Inner3 oi = new Outer3().new Inner3();
oi.show();
}
}
成員內部類修飾符:
private :為了保證數的安全性,外部類訪問成員內部類方法:外部類package day_09_10_24;
class Body{
public String heart;
//成員內部類
private class Inner{
public void operator(){
System.out.println("醫生做手術");
}
}
//成員方法
public void behave(){
boolean flag = true;
if(flag){
Inner i = new Inner();
i.operator();
}
}
}
public class MemberInnerPrivate {
public static void main(String[] args) {
/**
* 成員內部類被private修飾,直接建立外部類物件,通過外部類成員方法間接訪問內部類成員方法
* */
Body b = new Body();
b.behave();
}
}
static:為了方遍呼叫,如果成員內部類被static修飾,那麼要訪問外部類的成員變數,這個變數必須被static修飾 靜態的成員內部類訪問該類中的成員方法: 外部類名.內部類名 物件名 = new 外部類名.內部類名();
package day_09_10_24;
class Outer4{
//外部類的成員變數
public static int num1 = 10;
public static int num2 = 20;
/**
*對於靜態的成員內部類,無論其中的方法是靜態的還是非靜態的,要訪問外部類的成員變數,該變數必須被static修飾
**/
public static class Inner4{
//靜態的內部成員方法
public static void show(){
System.out.println("num1 = "+num1);
System.out.println("num2 = "+num2);
}
//非靜態的內部類的成員方法
public void show2(){
System.out.println("num1 = "+num1);
System.out.println("num2 = "+num2);
}
}
}
//測試類
public class MemberInnerStatic {
public static void main(String[] args) {
/**
* 需求:要訪問靜態成員內部類Inner4裡面的show(),show2()方法
* 外部類名.內部類名 物件名 = new 外部類名.內部類名();
* */
Outer4.Inner4 oi = new Outer4.Inner4();
oi.show2();
oi.show(); //靜態方法
System.out.println("------------");
//show的另一種訪問方法;
Outer4.Inner4.show(); //靜態方法可以直接通過類名方法
}
}
2)區域性內部類:定義在外區域性類的區域性位置
區域性內部類訪問該類中的成員方法:直接建立外部類的物件,通過外部類物件訪問外部類方法 結論:無論是區域性內部類還是成員內部類(非靜態的)都可以直接訪問外部類的成員,包括私有成員package day_09_10_24;
class Outer5{
public int num1 = 10;
private int num2 = 20;
//外部類的成員方法
public void method(){
//區域性變數
final int num3 = 20; //自定義常量
//區域性內部類
class Inner5{
public void show(){
System.out.println("num1 = "+num1);
System.out.println("num2 = "+num2);
//區域性內部類中訪問區域性變數
System.out.println("num3 = "+num3);//jdk1.7才會有這個錯誤! jdk1.8--->封裝好了,所以不會出現錯誤!
}
}
Inner5 i = new Inner5();
i.show();
}
}
//測試類
public class InnerLocal {
public static void main(String[] args) {
//對於區域性內部類訪問該類中的成員方法:建立外部類物件,使用外部類物件呼叫外部類的成員方法
Outer5 o = new Outer5();
o.method();
}
}
面試題:區域性內部類訪問區域性變數會出現問題?(比如上例中的區域性變數num3) 當前區域性變數會報錯,必須用final修飾; 為什麼用final修飾? 由於區域性變數是隨著方法呼叫而生產的,隨著方法的呼叫完畢消失,而現在區域性位置有一個區域性內部類,它要在自己的成員方法位置訪問當前的區域性變數,必須把變數變成一個常量(需要用final:自定義常量),這樣的一個變數的值是永遠固定的。
三.匿名內部類
內部類的簡化版格式 前提條件:必須存在一個介面或者一個類(可以是具體類,也可以是一個抽象類) 格式: new 介面或者類名{ 方法重寫; } 匿名內部類的實質:繼承了該類(抽象類)或者是實現了該介面的子類物件package day_09_10_24;
//定義一個介面
interface Inter9{
//抽象功能
public abstract void show();
public abstract void show2();
}
//外部類
class Outer6{
//成員方法
public void method(){
/*//當介面中只有一個方法的情況
new Inter9(){
public void show(){
System.out.println("匿名內部類");
}
}.show();
}*/
//匿名內部類.介面中有兩個方法的時候
Inter9 i = new Inter9(){
//方法重寫
public void show(){
System.out.println("show匿名內部類");
}
public void show2(){
System.out.println("show2匿名內部類");
}
};
i.show();
i.show2();
}
}
public class InnerDemo2 {
public static void main(String[] args) {
Outer6 o = new Outer6();
o.method();
}
}
package day_09_10_24;
/**
* 匿名內部類在開發中的使用
* */
interface Inter3{
public abstract void study();
}
class StudentDemo1{
public void method(Inter3 i){ //形式引數是介面
i.study();
}
}
//方式1:
class Adess implements Inter3{
public void study(){
System.out.println("好好學習,天天向上。。。");
}
}
public class OuterTest {
public static void main(String[] args) {
//呼叫StudentDemo1中的method()方法
StudentDemo1 sd = new StudentDemo1();
Inter3 i = new Adess();
sd.method(i);
//i.study();
System.out.println("---------------");
//方式2:匿名內部類
StudentDemo1 sd2 = new StudentDemo1();
sd2.method(new Inter3(){
//方法重寫
public void study(){
System.out.println("好好學習,天天向上。。。");
}
});
}
}
package day_09_10_24;
/**
* 匿名內部類面試題:
按照要求,補齊程式碼
interface Inter { void show(); }
class Outer { //補齊程式碼 }
public class InterTest {
public static void main(String[] args) {
Outer.method().show();
}
}
要求在控制檯輸出”HelloWorld”
分析:
* 當前method()能直接被類名呼叫---->method()方法是一個靜態方法static
* Outer.method().show()---->Outer.method()返回的是一個物件,拿物件呼叫show()方法
* 介面只有一個show()方法,需要重寫show()方法
* */
//介面
interface Inter5{
public abstract void show();
}
//外部類
class Outer8{
//補齊程式碼
public static Inter5 method(){ //返回值是一個介面
return new Inter5(){
//重寫show方法
public void show(){
System.out.println("HelloWorld!");
}
};
}
}
//測試類
public class InterTest {
public static void main(String[] args) {
Outer8.method().show();
}
}
package day_09_10_24;
/**
*
* 看程式
* 面試題:
要求請填空分別輸出30,20,10。
外部類和內部類沒有繼承關係!
* */
class Outer7 {
public int num = 10;
class Inner7 {
public int num = 20;
public void show() {
int num = 30;
System.out.println(num); //30
System.out.println(this.num); //20;this指當前物件
System.out.println(new Outer7().num);//10;要訪問外部類的成員變數:匿名物件 :new 外部類名().成員變數
//外部類的this限定
System.out.println(Outer7.this.num);//10
}
}
}
//測試類
public class InterclassTest {
public static void main(String[] args) {
Outer7.Inner7 oi = new Outer7().new Inner7();
oi.show();
}
}
相關推薦
形式引數-返回值-內部類-匿名內部類
一.形式引數和返回值 1.基本資料型別: 你要什麼資料型別,實際傳參的時候就傳什麼資料型別,形式引數的改變對實際引數沒有影響(String是引用型別,但和基本型別的效果一樣String s = "l
-1-2 java 面向物件基本概念 封裝繼承多型 變數 this super static 靜態變數 匿名物件 值傳遞 初始化過程 程式碼塊 final關鍵字 抽象類 介面 區別 多型 包 訪問許可權 內部類 匿名內部類 == 與 equal
java是純粹的面向物件的語言 也就是萬事萬物皆是物件 程式是物件的集合,他們通過傳送訊息來相互通訊 每個物件都有自己的由其他的物件所構建的儲存,也就是物件可以包含物件 每個物件都有它的型別 也就是類 某一特定型別的所有物件都可以接收相同的訊息,因為同一類事物有共同的特性 面向物件開發 •
內部類-區域性內部類-匿名內部類
內部類(常規內部類,靜態內部類),區域性內部類,匿名內部類。 下面的述語中,成員內部類是指常規內部類與靜態內部類。 getDeclaringClass():Class<?> 獲取成員內部類在定義時所在的類。 getEnclosingClass():C
java中介面內的匿名內部類
什麼是介面和匿名內部類 介面: java中的介面定義:多個抽象類的抽象就是介面. Java中的介面表示規範,用於定義一組抽象方法,表示某一類事物必須具備的功能,要求實現類必須來實現該介面並提供方法實現. Java介面的方法只能是抽
成員內部類.區域性內部類.靜態內部類.匿名內部類的區別
一 對於非靜態內部類,不能有靜態成員,例如變數,方法等。靜態內部類的非靜態成員可以訪問外部類的靜態變數,而不可訪問外部類的非靜態變數。非靜態內部類的非靜態成員可以訪問外部類的非靜態變數。 成員內部類可以隨意使用外部類的成員方法及成員變數,儘管這些類成員被修飾為private
java 內部類 匿名內部類 匿名類結合泛型 使用 詳細教程 講解
public class Inner{ public static void main(String[] args){ Xiao x = new Xiao(); x.study(); x.start().play(); //引數是匿名類的例項物件
靜態非靜態內部類匿名內部類區域性內部類
內部類有靜態內部類,靜態內部類,匿名內部類,區域性內部類 (1)非靜態內部類 直接在類的內部定義的類就是非靜態內部類,如下 public class Test { public static void main(String[] args) { Outer.Inner c1
靜態非靜態內部類匿名內部類局部內部類
stat 內部 實例 () 靜態內部類 靜態 外部類 通過 color 內部類有靜態內部類,靜態內部類,匿名內部類,局部內部類 (1)非靜態內部類 直接在類的內部定義的類就是非靜態內部類,如下 public class Test { public static v
內部類 匿名內部類與介面
內部類 成員內部類 靜態內部類 方法內部類 <span style="font-family:Microsoft YaHei;font-size:18px;">public Interface Iplay{ public void play();
day10 01_類,抽象類,介面的綜合小練習,02_形式引數和返回值的問題深入研究,03_包的概述和講解,04_修飾符的概述和總結,05_內部類概述和講解
01_類,抽象類,介面的綜合小練習 /* 教練和運動員案例(學生分析然後講解) 乒乓球運動員和籃球運動員。 乒乓球教練和籃球教練。 為了出國交流,跟乒乓球相關的人員都需要學習英語。 請用所學知識: 分析,這個案例中有哪些抽象類,哪些介面,哪些具體類。 整個分析過程,我是通過畫圖講解的。 */
javaSE引數傳遞問題、返回值問題、內部類總結
思維導圖 引數值傳遞問題 之前我們見到方法傳參一般傳遞的都是基本資料型別的引數,比如我要一個int型別,只需要在呼叫方法的時候傳一個int型別的數值就好了。但是當傳入引數需要一個引用資料型別,那麼該如何考慮呢? 類名作為傳入引數 class Studen
Java匿名內部類的傳值
在Nutz中,存在大量需要使用匿名內部類的情況,很多童鞋都對傳值很困惑,所以我這裡說明一下 傳入: //匿名內部類,只能訪問final的本地變數及方法引數publicvoid addUser(finalString name,String passwd,finalStrin
abstract;匿名內部類/單例設計模式/不用for迴圈求11000的值
目錄 單例設計模式 package com.day2_2015_7_21; //單例設計模式 public class Student1 { private static Student1 instance;//建立靜態物件
java匿名內部類 (轉載)
demo .cn 抽象方法 tab trac str adding strac oid 匿名內部類也就是沒有名字的內部類 正因為沒有名字,所以匿名內部類只能使用一次,它通常用來簡化代碼編寫 但使用匿名內部類還有個前提條件:必須繼承一個父類或實現一個接口 實例1:不使用匿
Java內部類之匿名內部類
urn nat 看到了 math 通過 rri 內部 test mat ??我們都知道Java中可以使用內部類,將一個類的定義放在另一個類的定義的內部,這就是內部類,但是匿名內部類往往使我們摸不著頭腦,因為它並沒有特定的名稱,那麽該如何使用它呢? 定義一個匿名內部類 pu
java匿名內部類的使用註意事項
trac 操作 num abs nal 部分 ets void name 1、首先匿名內部類要繼承自抽象基類或者實現基類接口 like this abstract class Seed{ int cnt; public Seed(int x){ cnt
為什麽說Java匿名內部類是殘缺的閉包
pan 年齡 pos 發生 clas 接下來 對象的引用 編譯器 xpl 前言 我們先來看一道很簡單的小題: public class AnonymousDemo1 { public static void main(String args[]) {
java匿名內部類
實現 lar 編寫 void pri com href show api show the code : package com.test.jwen.httpApiAuto; public class AInter { publi
內部類與匿名內部類
良好的 運行 實例 基本實現 產生 final 嚴重 代碼 組成 內部類不是很好理解,但說白了其實也就是一個類中還包含著另外一個類 如同一個人是由大腦、肢體、器官等身體結果組成,而內部類相當於其中的某個器官之一,例如心臟:它也有自己的屬性和行為(血液、跳動) 顯然,此
JavaSE8基礎 多線程 匿名內部類既重寫Thread中run,又實現Runnable中run
run compile 去掉 思考 release mpi window generate fix 禮悟: 好好學習多思考,尊師重道存感恩。葉見尋根三返一,活水清源藏於零。 虛懷若谷良心主,皓月當空自在王。願給最苦行無悔,誠勸且行且珍