匿名類
static修飾成員及訪問
package com.ice.test00;
/**
* @author lucky_ice
* 著作權：****
* 版本：version 1.0
*/
public class Animal {
//成員變數
int age;
String name;
//成員方法
public void eat() {
System.out.println("eat...");
}
/**
* 被static修飾的變數：靜態變數（類變數）
* 被static修飾的方法：靜態方法（類方法）
* 靜態變數和靜態方法稱為靜態成員
* 靜態成員通過"類名.“訪問（標準）或者”物件.“訪問（非標準，不推薦使用）
* <p>
* static修飾的方法或代碼塊中不能使用this與super
* static不能修飾構造器
*/
//靜態變數
static char sex;
static int foot;
//靜態方法
public static void sleep() {
System.out.println("sleep...");
}
public static void main(String[] args) {
//通過”類名.“訪問靜態成員
System.out.println(Animal.sex);
System.out.println(Animal.foot);
Animal.sleep();
//通過”物件.“訪問靜態成員 非標準的，不推薦使用
Animal a = new Animal();
System.out.println(a.sex);
System.out.println(a.foot);
a.sleep();
}
}
static應用
package com.ice.test;
/**
* @author lucky_ice
* 著作權：****
* 版本：version 1.0
*/
public class People {
private String name;
private int age;
private static String city;
public People() {
}
public People(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "People{" +
"name='" + name + '\'' +
", age=" + age +
", city='" + city + '\'' +
'}';
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
}
package com.ice.test;
/**
* @author lucky_ice
* 著作權：****
* 版本：version 1.0
*/
public class Test02 {
public static void main(String[] args) {
People p1 = new People("max", 23);
p1.setCity("北京");
System.out.println(p1);
People p2 = new People("小龍", 21);
p2.setCity("貴陽");
System.out.println(p2);
People p3 = new People("小敏", 22);
System.out.println(p3);
}
}
static初始化塊
package com.ice.test;
/**
* @author lucky_ice
* 著作權：****
* 版本：version 1.0
*/
public class Count {
public int number;
private static int count;//用于計數
//用于初始靜態變數，先于構造器執行
static {
System.out.println("類加載時執行了并且被執行一次");
count = 1;
}
public static int getCount() {
return count;
}
public Count() {
count++;
number = count;
System.out.println("構造器被執行");
}
}
package com.ice.test;
/**
* @author lucky_ice
* 著作權：****
* 版本：version 1.0
*/
public class Test01 {
public static void main(String[] args) {
Count c = new Count();
new Count();
System.out.println(c.number);
}
}
執行結果：
類加載時執行了并且被執行一次
構造器被執行
構造器被執行
2
單例設計模式
懶漢式
package com.ice.test01;
/**
* @author lucky_ice
* 著作權：****
* 版本：version 1.0
*/
//懶漢式
public class SingleTon {
public double r = Math.random();
private static SingleTon single = null;
//私有化構造器，不讓其他類創建物件
private SingleTon() {
}
//靜態工廠：專門用來生產類的實體
public static SingleTon getInstance() {
if (single == null) {
single = new SingleTon();
}
return single;
}
}
餓漢式
package com.ice.test02;
/**
* @author lucky_ice
* 著作權：****
* 版本：version 1.0
* 內部類：就是在一個類或方法中定義的類
* 內部類實際也是一個類，可以有成員變數和成員方法
* 分類：成員內部類，靜態內部類，區域內部類，匿名內部類
*/
//餓漢式
public class SingleTon {
public double r = Math.random();
private static SingleTon single = new SingleTon();
//私有化構造器，不讓其他類創建物件
private SingleTon() {
}
//靜態工廠：專門用來生產類的實體
public static SingleTon getInstance() {
return single;
}
}
package com.ice.test02;
/**
* @author lucky_ice
* 著作權：****
* 版本：version 1.0
*/
public class Test {
public static void main(String[] args) {
SingleTon single1 = SingleTon.getInstance();
System.out.println(single1.r);
SingleTon single2 = SingleTon.getInstance();
System.out.println(single2.r);
}
}
內部類的定義
public abstract class Animal {
public abstract void eat();
}
public interface Inf1 {
//啟動
public abstract void start();
}
public interface Inf2 {
//開始
public abstract void start();
}
public abstract class Other {
public abstract void othereat();
}
package com.ice.test03;
/**
* @author lucky_ice
* 著作權：****
* 版本：version 1.0
*/
//外部類
public class Outerclass extends Other implements Inf1 {
public static int a = 0;
@Override
public void start() {//啟動
}
@Override
public void othereat() {
}
//內部類
class InnerClass {
}
//內部類實作介面
class InnerClassInf implements Inf2 {
@Override
public void start() {//開始
}
}
//內部類繼承抽象類
class InnerClassAbstract extends Animal {
@Override
public void eat() {
}
}
}
類的內容
package com.ice.test04;
/**
* @author lucky_ice
* 著作權：****
* 版本：version 1.0
*/
public abstract class OuterClass {
int a;//成員變數
static int b;//靜態變數
final static int C = 10;//常量
{
//初始化塊
}
static {
//靜態初始化塊
}
public OuterClass() {
//構造器
}
public void fun1() {
//成員方法
}
public static void fun2() {
//靜態成員方法
}
public abstract void fun3();//抽象方法
class InnerClass {
//內部類
}
}
成員內部類
package com.ice.test05;
/**
* @author lucky_ice
* 著作權：****
* 版本：version 1.0
*/
public class OuterClass {
int a = 10;//成員變數
static int b = 20;//靜態變數
/**
* 在外部類中訪問成員內部類:new 內部類名().內部類物件
*/
//成員方法
public void fun() {
System.out.println(new InnerClass().x);
}
//成員內部類
class InnerClass {
int x = 10;
// static int y=20;//內部類中不能存在靜態成員
/**
* 在成員內部類中訪問外部類：外部類類名.this.外部類物件
* this在內部類中表示當前的內部類物件
*/
public void fun() {
System.out.println(OuterClass.this.a);
System.out.println(this.x);
}
}
}
靜態內部類
package com.ice.test06;
/**
* @author lucky_ice
* 著作權：****
* 版本：version 1.0
*/
//外部類
public class OuterClass {
//靜態內部類
public static class InnerClass {
public static int a = 10;
public static void fun() {
System.out.println("statie fun...");
}
}
public void test() {
System.out.println(InnerClass.a);
}
}
package com.ice.test006;
import com.ice.test06.OuterClass;
/**
* @author lucky_ice
* 著作權：****
* 版本：version 1.0
*/
public class Test {
public void m() {
System.out.println(OuterClass.InnerClass.a);
}
}
區域內部類
package com.ice.test07;
/**
* @author lucky_ice
* 著作權：****
* 版本：version 1.0
*/
public class OuterClass {
public int a = 10;
public void fun() {
//區域變數
final int x = 100;
/**
* 區域內部類：定義在方法內部或引數位置
* 作用域只在該方法內有效，不能使用權限修飾符
*/
class InnerClass {
public void test() {
System.out.println(OuterClass.this.a);//訪問外部類成員，通過“外部類名.this.外部物件
System.out.println(x);//訪問方法的區域變數，但是這個區域變數必須由final修飾
}
}
}
}
匿名內部類
package com.ice.test08;
/**
* @author lucky_ice
* 著作權：****
* 版本：version 1.0
*/
public class Animal {
public void eat() {
System.out.println("Animal...");
}
}
package com.ice.test08;
/**
* @author lucky_ice
* 著作權：****
* 版本：version 1.0
* 匿名內部類：
* 1.在成員變數賦值時創建
* 2.在方法內部定義并直接使用
* 3.在方法引數位置創建
*/
//外部類
public class NoNameClass {
Animal a = null;//宣告參考物件時使用默認值null
Animal a2 = new Animal();//宣告參考變數時就創建物件
/**
* 1.在成員變數賦值時創建
*/
//宣告參考變數并創建匿名內部類物件 new 類名（）{}--->匿名內部類物件
Animal a3 = new Animal() {
@Override
public void eat() {
super.eat();
}
};
/**
* 2.在方法內部定義并直接使用
*/
public void fun() {
//匿名內部類--->匿名物件，用完一次就回收
new Animal() {
};
Animal a = new Animal() {
@Override
public void eat() {
System.out.println("匿名內部類的eat方法");
}
};
a.eat();
}
/**
* 3.在方法引數位置創建
*
* @param a
*/
public void m(Animal a) {
}
public static void main(String[] args) {
new NoNameClass().m(new Animal() {//在方法引數位置創建
});
}
}
//普通類
public class Animal {
public void sleep() {
}
}
//抽象類
public abstract class Computer {
public abstract void play();
}
//介面
public interface Mouse {
public abstract void click();
}
package com.ice.test09;
/**
* @author lucky_ice
* 著作權：****
* 版本：version 1.0
*/
public class NoNameClass {
//普通類實作匿名內部類
Animal a = new Animal() {
@Override
public void sleep() {
System.out.println("匿名內部類的sleep()方法");
}
};
//抽象類實作匿名內部類：在匿名內部類中必須重寫抽象方法
Computer c = new Computer() {
@Override
public void play() {
System.out.println("匿名內部類的play()方法");
}
};
//介面實作匿名內部類:在匿名內部類中必須重寫抽象方法
Mouse m = new Mouse() {
@Override
public void click() {
}
};
}
使用匿名內部類作為引數傳遞
package com.ice.test10;
/**
* @author lucky_ice
* 著作權：****
* 版本：version 1.0
*/
//普通類
public class Animal {
public void sleep() {
System.out.println("Animal sleep...");
}
}
class Dog extends Animal {
@Override
public void sleep() {
System.out.println("Dog sleep");
}
}
package com.ice.test10;
/**
* @author lucky_ice
* 著作權：****
* 版本：version 1.0
*/
//抽象類
public abstract class Computer {
public abstract void play();
}
class MyComputer extends Computer {
@Override
public void play() {
System.out.println("MyComputer play...");
}
}
package com.ice.test10;
/**
* @author lucky_ice
* 著作權：****
* 版本：version 1.0
*/
//介面
public interface Mouse {
public abstract void click();
}
class Lenovo implements Mouse {
@Override
public void click() {
System.out.println("Lenovo click...");
}
}
package com.ice.test10;
/**
* @author lucky_ice
* 著作權：****
* 版本：version 1.0
*/
public class NoNameClass {
/**
* 普通內部類作為引數時:可以傳普通類物件、子類物件、匿名內部類物件
*/
public void m1(Animal a) {
a.sleep();
}
/**
* 抽象類作為引數時：可以傳遞子類物件，匿名內部類物件
*
* @param c
*/
public void m2(Computer c) {
c.play();
}
/**
* 引數作為介面時：可以傳遞實作類物件，匿名內部類物件
*
* @param m
*/
public void m3(Mouse m) {
m.click();
}
}
package com.ice.test10;
/**
* @author lucky_ice
* 著作權：****
* 版本：version 1.0
*/
public class Test {
public static void main(String[] args) {
NoNameClass n = new NoNameClass();
//呼叫引數為普通類的方法
n.m1(new Animal());//Animal a=new Animal();
n.m1(new Dog());//Animal a=new Dog();//向上轉型
n.m1(new Animal() {//Animal a=匿名內部類物件
@Override
public void sleep() {
System.out.println("普通類實作匿名內部類");
}
});
//呼叫引數為抽象類的方法
n.m2(new MyComputer());//Computer c=new MyComputer 向上轉型
n.m2(new Computer() {
@Override
public void play() {
System.out.println("抽象類實作匿名內部類");
}
});
//呼叫引數為介面的方法
n.m3(new Lenovo());//Mouse m=new Lenove();//向上轉型
n.m3(new Mouse() {
@Override
public void click() {
System.out.println("介面實作匿名內部類");
}
});
}
}
作業
1、內部類的使用：
（1）定義一個外部類Father，有成員變數name并賦一個初值，
（2）定義一個內部類Child，并定義一個getValue()方法，在方法中呼叫外部類Father的name變數，
（3）定義一個測驗類，在測驗類的main方法中創建Child物件，并呼叫getValue()方法
package com.ice.test11;
/**
* @author lucky_ice
* 著作權：****
* 版本：version 1.0
*/
public class Father {
private String name = "max";
class Child {
public void getValue() {
System.out.println(Father.this.name);
}
}
public void getValue() {
Child c = new Child();
c.getValue();
}
}
package com.ice.test11;
/**
* @author lucky_ice
* 著作權：****
* 版本：version 1.0
*/
public class Test {
public static void main(String[] args) {
Father f = new Father();
f.getValue();
}
}
轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/119262.html
標籤：其他
上一篇：python面向物件-1