public class TestMemberInner{
public static void main(String[] args){
Outer.Inner in1 = new Outer().new Inner();
in1.test();
Outer out = new Outer();
Outer.Inner in2 = out.new Inner();
in2.test();
}
}
class Outer{
int a = 3;//成员变量 = 实例变量 =属性
static int b = 4;//静态变量
class Inner{
int x = 5;
public void test(){//成员内部类
System.out.println(a);
System.out.println(b);
System.out.println(x);
}
}
}
public class TestStaticInner{
public static void main(String[] args){
Outer.Inner in1 = new Outer.Inner();
in1.test();
}
}
class Outer{
int a = 3;
static int b = 4;
static class Inner{//静态内部类
int x = 5;
static int y = 5;
public void test(){
//System.out.println(a); 无法从静态上下文访问非静态变量
System.out.println(b);
System.out.println(x);//取决于test是否是非静态的
System.out.println(y);
}
}
}
如何创建其对象:Inner in = new Inner();注意:有位置限定(定义完成之后,所在方法结束之前)
public class TestLocalInner{
public static void main(String[] args){
}
}
class Outer{
int a = 3;
static int b = 4;
public void gogo(int c){
int d = 7;
class Inner{//局部内部类
int x = 9;
public void test(){
System.out.println(a);//取决于test是否是非静态的
System.out.println(b);
System.out.println(c);//取决于jdk版本
System.out.println(d);//取决于jdk版本
System.out.println(x);
}
}
//Inner
Inner in = new Inner();
in.test();
}
}
匿名内部类:比如某些场景下,我们自己的名字无关紧要,反而长辈的名字才重要
语法--继承父类:new 父类(给父类构造方法传参){ 完成方法覆盖; }
语法--实现接口:new 接口(){ 完成抽象方法的具体实现 }
能够共享外部类的哪些内容?完全取决于它的位置,可能等价于上述三种的某一种
import java.util.*;
public class TestAnonyInner1{
public static void main(String[] args){
//一个实现了Comparetor接口的,但是没有名字的 类的对象
Set<Integer> set = new TreeSet<>(new Comparator<Integer>(){
@Override
public int compare(Integer i1,Integer i2){
return i2.compareTo(i1);
}
});
Collections.addAll(set,55,33,44,11,22);
//降序排序
System.out.println(set);
}
}
public class TestAnonyInner2{
public static void main(String[] args){
//使用标准语法创建一个学生对象,并调用方法
Student stu = new Student();
stu.eat();
//请使用匿名内部类语法创建一个老师对象 并调用方法
Person p = new Person("孔子"){
@Override
public void eat(){
System.out.println("老师吃包子");
}
};
p.eat();
}
}
abstract class Person{
String name;
public Person(String name){
this.name = name;
}
public abstract void eat();
}
class Student extends Person{
public Student(){
super("子贡");
}
@Override
public void eat(){
System.out.println("学生吃饺子");
}
}
public class TestAnonyInnerPlus{
public static void main(String[] args){
//降序排序
Set<Integer> set = new TreeSet<>((a,b) -> b.compareTo(a));
Collections.addAll(set,55,33,44,11,22);
System.out.println(set);
}
}
java中如何完成数据共享:
使用静态变量完成数据共享
使用参数传递完成数据共享(优先选Setter即set方法)
使用内部类完成数据共享
//1.使用静态变量完成数据共享
public class TestShareData1{
public static void main(String[] args){
吕布 lxb = new 吕布();
董卓 daz = new 董卓();
lxb.test();
daz.test();
}
}
class 广寒宫{
static Object 貂蝉 = new Object();
}
class 吕布{
public void test(){
System.out.println(广寒宫.貂蝉);
}
}
class 董卓{
public void test(){
System.out.println(广寒宫.貂蝉);
}
}
//2.使用参数传递完成数据共享
public class TestShareData2{
public static void main(String[] args){
Object 貂蝉 = new Object();
吕布 lxb = new 吕布(貂蝉);
董卓 ddz = new 董卓(貂蝉);
lxb.test();
ddz.test();
}
}
class 吕布{
Object 夫人;
public 吕布(Object 夫人){
this.夫人 = 夫人;
}
public void test(){
System.out.println(夫人);
}
}
class 董卓{
Object 夫人;
public 董卓(Object 夫人){
this.夫人 = 夫人;
}
public void test(){
System.out.println(夫人);
}
}
//3.使用内部类完成数据共享
public class Test{
public static void main(String[] args){
广寒宫 g = new 广寒宫();
广寒宫.吕布 lxb = g.new 吕布();
广寒宫.董卓 ddz = g.new 董卓();
lxb.test();
ddz.test();
}
}
class 广寒宫{
Object 貂蝉 = new Object();
class 吕布{
public void test(){
System.out.println(貂蝉);
}
}
class 董卓{
public void test(){
System.out.println(貂蝉);
}
}
}
/**
一个凄美的爱情故事:
主角是一对小情侣
一个小男孩和一个小女孩
他们两个约会去看电影 但是钱不太多
于是 买了两张电影票之后 只够买一杯大可乐
他们找服务员要了两根吸管 共享同一杯大可乐
使用数据共享的三种方式实现,参数传递的用Setter
*/
public class shareDate1{
public static void main(String[] args){
Boy b = new Boy();
Girl g = new Girl();
b.test();
g.test();
}
}
class Cinema{
/**
static修饰的变量叫做静态变量
不是每一个对象都有一份,而是整个类型共享一份的
不依赖任何一个对象而存在
使用静态变量可以使用类名.变量名直接访问
*/
static Object cola = new Object();
}
class Boy{
public void test(){
System.out.println(Cinema.cola);
}
}
class Girl{
public void test(){
System.out.println(Cinema.cola);
}
}
public class shareDate2{
public static void main(String[] args){
Object cola = new Object();
Boy b = new Boy();
b.setWdyl(cola);
Girl g = new Girl();
g.setTdyl(cola);
b.test();
g.test();
}
}
class Boy{
Object wdyl;
public void setWdyl(Object wdyl){
this.wdyl = wdyl;
}
public void test(){
System.out.println(wdyl);
}
}
class Girl{
Object tdyl;
public void setTdyl(Object tdyl){
this.tdyl = tdyl;
}
public void test(){
System.out.println(tdyl);
}
}
public class shareDate3{
public static void main(String[] args){
Cinema c = new Cinema();
Cinema.Boy xl = c.new Boy();
Cinema.Girl xh = c.new Girl();
xl.test();
xh.test();
}
}
class Cinema{
Object cola = new Object();
class Boy{
public void test(){
System.out.println(cola);
}
}
class Girl{
public void test(){
System.out.println(cola);
}
}
}
public class TestPlus01{
public static void main(String[] args){
A.C cc = new A().new C();
cc.test();
}
}
class D{
int i = 7;
}
class A{
int i = 3;
class C extends D{
int i = 9;
public void test(){
System.out.println(i);//?
System.out.println(this.i);
System.out.println(C.this.i);
System.out.println(A.this.i);
System.out.println(super.i);
System.out.println(C.super.i);
}
}
}
public class TestPlus02{
public static void main(String[] args){
Student stu = new Student();
Teacher tea = new Teacher();
tea.setMyStudent(stu);
stu.setMyTeacher(tea);
}
}
class Student{
Teacher myTeacher;
public void setMyTeacher(Teacher myTeacher){
this.myTeacher = myTeacher;
}
}
class Teacher{
Student myStudent;
public void setMyStudent(Student myStudent){
this.myStudent = myStudent;
}
}