目录
5.抽象类和接口
1.抽象类
2.接口
3.例题
1.模拟笔记本电脑接口案例
2.会员卡打折案例
3.不同几何体面积案例
4.写作文案例
6.内部类及OOP实战
1.成员内部类、局部内部类
2.匿名内部类
5.抽象类和接口
1.抽象类
关键字：abstract
1.不能new这个抽象类，只能靠子类去实现它（这就是一个约束条件）得到了抽象方法，失去了创建对象的能力，调用需要使用多态，实例化子类，来引用父类的东西
2.抽象类中可以写普通的方法
3.抽象类可以不定义抽象方法，但是有抽象方法的一定是抽象类(抽象方法必须在抽象类中)
4.抽象类存在构造器
5.抽象类可以封装
6.抽象类中可以实现也可以派生，但是不能实现自己的抽象方法，可以实现父类的抽象方法
7.子类必须重写父类的所有抽象方法，除非这个类也是抽象类，那就一直继承到可以实现的类
8.抽象类默认有无参构造
9.不能用abstract修饰变量、代码块、构造器。
10.abstract定义的抽象类作为模板让子类继承，final定义的类不能被继承，更不能被重写(互斥关系)
抽象类存在的意义：
1.抽象类的核心意义就是为了被子类继承（就是为了派生子类），否则抽象类毫无意义！（就是让子类必须实现父类的抽象方法）
2.抽象类体现的是模板思想，部分实现，部分抽象，可以设计模板设计模式
非法修饰符：
abstract和private就是非法组合,抽象方法要重写,private不能继承
abstract和final就是非法组合,抽象方法要重写,final修饰不能重写
abstract和static就是非法组合,静态方法类名直接调用
例：
package java_jichu.mianxiangduixiang.demo10;
//abstract 抽象类
public abstract class Action {
//约束 有人帮我们实现
//abstract 抽象方法，只有方法名字，没有方法实现
public abstract void doSomething();
}
2.接口
关键字：implements
◆普通类:只有具体实现
◆抽象类:具体实现和规范(抽象方法)都有!
◆接口:只有规范!自己无法写方法~
◆接口就是规范(约束)只能让子类实现
◆OO的精髓，是对对象的抽象，最能体现这一点的就是接口。
作用：
1.约束
2.定义一些方法，让不同的人实现 就比如让十个员工去做一个接口10 -> 1
3.public abstract 接口的默认方法 void(基本数据类型) xxx()；抽象方法名(设置一个形参，实现类需要实例化赋值)
4.public static final 默认常量 int A；或者int A=9
5.接口不能被实例化,因为接口中没有构造方法(不能new),调用需要子类多态父类去调用父类成员变量
6.implements可以实现多个 接口，一个类可以实现多个接口，接口和接口之间是继承关系，支持多继承或继承多个接口，多个接口的规范不能冲突，多个接口中有同样的静态方法不冲突
7.一个类继承了父类，同时又实现了接口，父类中和接口中有同名方法，默认用父类的。
8.接口中只能是抽象方法和常量
9.接口中的成员都是public修饰的，写不写都是，因为规范的目的是为了公开化
10.接口没有构造器
11.一个类实现接口，必须重写完全部接口的全部抽象方法，否则这个类需要定义成抽象类然后将剩余的实现给子类的实现类去实现。
12.实现类必须要重写接口中的抽象方法。
例：
package java_jichu.mianxiangduixiang.demo11;
//抽象类 extends单继承
//类 可以实现接口 implements 接口
//实现了接口的类，就需要重写接口中的方法
public class UserServiceImpl implements UserService,TimeService{
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
@Override
public void timer() {
}
}
3.例题
1.模拟笔记本电脑接口案例
package java_se.java_jichu.zuoye_8_9.demo01;
public class TestComputer {
public static void main(String[] args) {
Computer c1 = new Computer();
//开启电脑
c1.powerOn();
//多态 方法编译看左边，运行看右边 成员变量编译看左边，运行也看左边
USB usb1 = new USBImpl1();
//电脑里面的方法赋值为鼠标
c1.useDevice(usb1);//判断比较值
USBImpl2 usb2 = new USBImpl2();
c1.useDevice(usb2);
c1.powerOff();
}
}
2.会员卡打折案例
package java_se.java_jichu.zuoye_8_9.demo02;
public class TextYinHang {
public static void main(String[] args) {
//调用jin类
Jin jin = new Jin();
//给从父类获取的封装值赋值
jin.setMoney(10000);
jin.setName("金卡王");
//给pay形参给赋一个实参
jin.pay(300);
//用完方法后剩余的金额
System.out.println("剩余: " + jin.getMoney());
System.out.println("--------------------------");
Yin yin = new Yin();
yin.setMoney(5000);
yin.setName("银卡王");
yin.pay(500);
System.out.println("剩余: " + yin.getMoney());
}
}
3.不同几何体面积案例
package java_se.java_jichu.zuoye_8_9.demo3;
public class TestMianJi {
public static void main(String[] args) {
San san = new San();
san.setHeight(3);
san.setWinth(5);
san.setName("三角形");
san.area();
System.out.println("--------------");
Ju ju = new Ju("矩形",1,2);
ju.area();
}
}
4.写作文案例
package java_se.java_jichu.zuoye_8_9.demo4;
import java_se.java_jichu.zuoye_8_9.demo3.San;
public class TestZW {
public static void main(String[] args) {
//调用作文的方法
ZuoWen zuoWen = new ZuoWen();
//调用中学生的方法
ZStudent zStudent = new ZStudent();
//给中学生的父类的属性赋值
zStudent.setName("中学生");
//输出作文的Xie方法实参值为zStudent(被调用的中学生类)
zuoWen.Xie(zStudent);
System.out.println("===============");
//调用小学生的方法
XStudent xStudent = new XStudent();
//给中学生的父类的属性赋值
xStudent.setName("小学生");
//输出作文的Xie方法实参值为xStudent(被调用的小学生类)
zuoWen.Xie(xStudent);
}
}
6.内部类及OOP实战
◆内部类就是在-个类的内部在定义-个类，比如，A类中定义-个B类,那么B类相对A类来说就称为内部类,而A类相对B类来说就是外部类了。
◆1.成员内部类
◆2.静态内部类
◆3.局部内部类
◆4.匿名内部类
1.成员内部类、局部内部类
package java_jichu.mianxiangduixiang.demo12;
public class Outer {
// 一
// private int id=10;
// public void out(){
// System.out.println("这是外部类的方法");
// }
// (1)
// public class Inner{
// public void in(){
// System.out.println("这是内部类的方法");
// }
// (2)
// //获得外部类的私有属性
// public void getID(){
// System.out.println(id);
// }
// }
// 三
//局部内部类
public void method(){
class Inner{
public void in(){
}
}
}
}
//二
//一个java类中可以有多个class类，但只能有一个public class
//class A{
// public static void main(String[] args) {
//
// }
//}
2.匿名内部类
package java_jichu.mianxiangduixiang.demo12;
public class Test {
public static void main(String[] args) {
//没有名字初始化类，不用实例保存到变量中
new Apple().eat();
new UserService(){//UserService userService new UserService() 必须要重写里面的方法
@Override
public void hello() {
}
};
}
}
class Apple{
public void eat(){
System.out.println("1");
}
}
interface UserService{
void hello();
}
关键字：abstract
1.不能new这个抽象类，只能靠子类去实现它（这就是一个约束条件）得到了抽象方法，失去了创建对象的能力，调用需要使用多态，实例化子类，来引用父类的东西
2.抽象类中可以写普通的方法
3.抽象类可以不定义抽象方法，但是有抽象方法的一定是抽象类(抽象方法必须在抽象类中)
4.抽象类存在构造器5.抽象类可以封装
6.抽象类中可以实现也可以派生，但是不能实现自己的抽象方法，可以实现父类的抽象方法
7.子类必须重写父类的所有抽象方法，除非这个类也是抽象类，那就一直继承到可以实现的类
8.抽象类默认有无参构造
9.不能用abstract修饰变量、代码块、构造器。
10.abstract定义的抽象类作为模板让子类继承，final定义的类不能被继承，更不能被重写(互斥关系)
抽象类存在的意义：
1.抽象类的核心意义就是为了被子类继承（就是为了派生子类），否则抽象类毫无意义！（就是让子类必须实现父类的抽象方法）
2.抽象类体现的是模板思想，部分实现，部分抽象，可以设计模板设计模式非法修饰符：
abstract和private就是非法组合,抽象方法要重写,private不能继承
abstract和final就是非法组合,抽象方法要重写,final修饰不能重写
abstract和static就是非法组合,静态方法类名直接调用
例：
package java_jichu.mianxiangduixiang.demo10;
//abstract 抽象类
public abstract class Action {
//约束 有人帮我们实现
//abstract 抽象方法，只有方法名字，没有方法实现
public abstract void doSomething();
}
2.接口
关键字：implements
◆普通类:只有具体实现
◆抽象类:具体实现和规范(抽象方法)都有!
◆接口:只有规范!自己无法写方法~
◆接口就是规范(约束)只能让子类实现
◆OO的精髓，是对对象的抽象，最能体现这一点的就是接口。
作用：
1.约束
2.定义一些方法，让不同的人实现 就比如让十个员工去做一个接口10 -> 1
3.public abstract 接口的默认方法 void(基本数据类型) xxx()；抽象方法名(设置一个形参，实现类需要实例化赋值)
4.public static final 默认常量 int A；或者int A=9
5.接口不能被实例化,因为接口中没有构造方法(不能new),调用需要子类多态父类去调用父类成员变量
6.implements可以实现多个 接口，一个类可以实现多个接口，接口和接口之间是继承关系，支持多继承或继承多个接口，多个接口的规范不能冲突，多个接口中有同样的静态方法不冲突
7.一个类继承了父类，同时又实现了接口，父类中和接口中有同名方法，默认用父类的。
8.接口中只能是抽象方法和常量
9.接口中的成员都是public修饰的，写不写都是，因为规范的目的是为了公开化
10.接口没有构造器
11.一个类实现接口，必须重写完全部接口的全部抽象方法，否则这个类需要定义成抽象类然后将剩余的实现给子类的实现类去实现。
12.实现类必须要重写接口中的抽象方法。
例：
package java_jichu.mianxiangduixiang.demo11;
//抽象类 extends单继承
//类 可以实现接口 implements 接口
//实现了接口的类，就需要重写接口中的方法
public class UserServiceImpl implements UserService,TimeService{
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
@Override
public void timer() {
}
}
3.例题
1.模拟笔记本电脑接口案例
package java_se.java_jichu.zuoye_8_9.demo01;
public class TestComputer {
public static void main(String[] args) {
Computer c1 = new Computer();
//开启电脑
c1.powerOn();
//多态 方法编译看左边，运行看右边 成员变量编译看左边，运行也看左边
USB usb1 = new USBImpl1();
//电脑里面的方法赋值为鼠标
c1.useDevice(usb1);//判断比较值
USBImpl2 usb2 = new USBImpl2();
c1.useDevice(usb2);
c1.powerOff();
}
}
2.会员卡打折案例
package java_se.java_jichu.zuoye_8_9.demo02;
public class TextYinHang {
public static void main(String[] args) {
//调用jin类
Jin jin = new Jin();
//给从父类获取的封装值赋值
jin.setMoney(10000);
jin.setName("金卡王");
//给pay形参给赋一个实参
jin.pay(300);
//用完方法后剩余的金额
System.out.println("剩余: " + jin.getMoney());
System.out.println("--------------------------");
Yin yin = new Yin();
yin.setMoney(5000);
yin.setName("银卡王");
yin.pay(500);
System.out.println("剩余: " + yin.getMoney());
}
}
3.不同几何体面积案例
package java_se.java_jichu.zuoye_8_9.demo3;
public class TestMianJi {
public static void main(String[] args) {
San san = new San();
san.setHeight(3);
san.setWinth(5);
san.setName("三角形");
san.area();
System.out.println("--------------");
Ju ju = new Ju("矩形",1,2);
ju.area();
}
}
4.写作文案例
package java_se.java_jichu.zuoye_8_9.demo4;
import java_se.java_jichu.zuoye_8_9.demo3.San;
public class TestZW {
public static void main(String[] args) {
//调用作文的方法
ZuoWen zuoWen = new ZuoWen();
//调用中学生的方法
ZStudent zStudent = new ZStudent();
//给中学生的父类的属性赋值
zStudent.setName("中学生");
//输出作文的Xie方法实参值为zStudent(被调用的中学生类)
zuoWen.Xie(zStudent);
System.out.println("===============");
//调用小学生的方法
XStudent xStudent = new XStudent();
//给中学生的父类的属性赋值
xStudent.setName("小学生");
//输出作文的Xie方法实参值为xStudent(被调用的小学生类)
zuoWen.Xie(xStudent);
}
}
6.内部类及OOP实战
◆内部类就是在-个类的内部在定义-个类，比如，A类中定义-个B类,那么B类相对A类来说就称为内部类,而A类相对B类来说就是外部类了。
◆1.成员内部类
◆2.静态内部类
◆3.局部内部类
◆4.匿名内部类
1.成员内部类、局部内部类
package java_jichu.mianxiangduixiang.demo12;
public class Outer {
// 一
// private int id=10;
// public void out(){
// System.out.println("这是外部类的方法");
// }
// (1)
// public class Inner{
// public void in(){
// System.out.println("这是内部类的方法");
// }
// (2)
// //获得外部类的私有属性
// public void getID(){
// System.out.println(id);
// }
// }
// 三
//局部内部类
public void method(){
class Inner{
public void in(){
}
}
}
}
//二
//一个java类中可以有多个class类，但只能有一个public class
//class A{
// public static void main(String[] args) {
//
// }
//}
2.匿名内部类
package java_jichu.mianxiangduixiang.demo12;
public class Test {
public static void main(String[] args) {
//没有名字初始化类，不用实例保存到变量中
new Apple().eat();
new UserService(){//UserService userService new UserService() 必须要重写里面的方法
@Override
public void hello() {
}
};
}
}
class Apple{
public void eat(){
System.out.println("1");
}
}
interface UserService{
void hello();
}
关键字：implements
◆普通类:只有具体实现
◆抽象类:具体实现和规范(抽象方法)都有!
◆接口:只有规范!自己无法写方法~
◆接口就是规范(约束)只能让子类实现
◆OO的精髓，是对对象的抽象，最能体现这一点的就是接口。
作用：
1.约束
2.定义一些方法，让不同的人实现 就比如让十个员工去做一个接口10 -> 1
3.public abstract 接口的默认方法 void(基本数据类型) xxx()；抽象方法名(设置一个形参，实现类需要实例化赋值)
4.public static final 默认常量 int A；或者int A=9
5.接口不能被实例化,因为接口中没有构造方法(不能new),调用需要子类多态父类去调用父类成员变量
6.implements可以实现多个 接口，一个类可以实现多个接口，接口和接口之间是继承关系，支持多继承或继承多个接口，多个接口的规范不能冲突，多个接口中有同样的静态方法不冲突
7.一个类继承了父类，同时又实现了接口，父类中和接口中有同名方法，默认用父类的。
8.接口中只能是抽象方法和常量
9.接口中的成员都是public修饰的，写不写都是，因为规范的目的是为了公开化
10.接口没有构造器
11.一个类实现接口，必须重写完全部接口的全部抽象方法，否则这个类需要定义成抽象类然后将剩余的实现给子类的实现类去实现。
12.实现类必须要重写接口中的抽象方法。
1.模拟笔记本电脑接口案例
package java_se.java_jichu.zuoye_8_9.demo01;
public class TestComputer {
public static void main(String[] args) {
Computer c1 = new Computer();
//开启电脑
c1.powerOn();
//多态 方法编译看左边，运行看右边 成员变量编译看左边，运行也看左边
USB usb1 = new USBImpl1();
//电脑里面的方法赋值为鼠标
c1.useDevice(usb1);//判断比较值
USBImpl2 usb2 = new USBImpl2();
c1.useDevice(usb2);
c1.powerOff();
}
}
2.会员卡打折案例
package java_se.java_jichu.zuoye_8_9.demo02;
public class TextYinHang {
public static void main(String[] args) {
//调用jin类
Jin jin = new Jin();
//给从父类获取的封装值赋值
jin.setMoney(10000);
jin.setName("金卡王");
//给pay形参给赋一个实参
jin.pay(300);
//用完方法后剩余的金额
System.out.println("剩余: " + jin.getMoney());
System.out.println("--------------------------");
Yin yin = new Yin();
yin.setMoney(5000);
yin.setName("银卡王");
yin.pay(500);
System.out.println("剩余: " + yin.getMoney());
}
}
3.不同几何体面积案例
package java_se.java_jichu.zuoye_8_9.demo3;
public class TestMianJi {
public static void main(String[] args) {
San san = new San();
san.setHeight(3);
san.setWinth(5);
san.setName("三角形");
san.area();
System.out.println("--------------");
Ju ju = new Ju("矩形",1,2);
ju.area();
}
}
4.写作文案例
package java_se.java_jichu.zuoye_8_9.demo4;
import java_se.java_jichu.zuoye_8_9.demo3.San;
public class TestZW {
public static void main(String[] args) {
//调用作文的方法
ZuoWen zuoWen = new ZuoWen();
//调用中学生的方法
ZStudent zStudent = new ZStudent();
//给中学生的父类的属性赋值
zStudent.setName("中学生");
//输出作文的Xie方法实参值为zStudent(被调用的中学生类)
zuoWen.Xie(zStudent);
System.out.println("===============");
//调用小学生的方法
XStudent xStudent = new XStudent();
//给中学生的父类的属性赋值
xStudent.setName("小学生");
//输出作文的Xie方法实参值为xStudent(被调用的小学生类)
zuoWen.Xie(xStudent);
}
}
6.内部类及OOP实战
◆内部类就是在-个类的内部在定义-个类，比如，A类中定义-个B类,那么B类相对A类来说就称为内部类,而A类相对B类来说就是外部类了。
◆1.成员内部类
◆2.静态内部类
◆3.局部内部类
◆4.匿名内部类
1.成员内部类、局部内部类
package java_jichu.mianxiangduixiang.demo12;
public class Outer {
// 一
// private int id=10;
// public void out(){
// System.out.println("这是外部类的方法");
// }
// (1)
// public class Inner{
// public void in(){
// System.out.println("这是内部类的方法");
// }
// (2)
// //获得外部类的私有属性
// public void getID(){
// System.out.println(id);
// }
// }
// 三
//局部内部类
public void method(){
class Inner{
public void in(){
}
}
}
}
//二
//一个java类中可以有多个class类，但只能有一个public class
//class A{
// public static void main(String[] args) {
//
// }
//}
2.匿名内部类
package java_jichu.mianxiangduixiang.demo12;
public class Test {
public static void main(String[] args) {
//没有名字初始化类，不用实例保存到变量中
new Apple().eat();
new UserService(){//UserService userService new UserService() 必须要重写里面的方法
@Override
public void hello() {
}
};
}
}
class Apple{
public void eat(){
System.out.println("1");
}
}
interface UserService{
void hello();
}
package java_se.java_jichu.zuoye_8_9.demo02;
public class TextYinHang {
public static void main(String[] args) {
//调用jin类
Jin jin = new Jin();
//给从父类获取的封装值赋值
jin.setMoney(10000);
jin.setName("金卡王");
//给pay形参给赋一个实参
jin.pay(300);
//用完方法后剩余的金额
System.out.println("剩余: " + jin.getMoney());
System.out.println("--------------------------");
Yin yin = new Yin();
yin.setMoney(5000);
yin.setName("银卡王");
yin.pay(500);
System.out.println("剩余: " + yin.getMoney());
}
}
3.不同几何体面积案例
package java_se.java_jichu.zuoye_8_9.demo3;
public class TestMianJi {
public static void main(String[] args) {
San san = new San();
san.setHeight(3);
san.setWinth(5);
san.setName("三角形");
san.area();
System.out.println("--------------");
Ju ju = new Ju("矩形",1,2);
ju.area();
}
}
4.写作文案例
package java_se.java_jichu.zuoye_8_9.demo4;
import java_se.java_jichu.zuoye_8_9.demo3.San;
public class TestZW {
public static void main(String[] args) {
//调用作文的方法
ZuoWen zuoWen = new ZuoWen();
//调用中学生的方法
ZStudent zStudent = new ZStudent();
//给中学生的父类的属性赋值
zStudent.setName("中学生");
//输出作文的Xie方法实参值为zStudent(被调用的中学生类)
zuoWen.Xie(zStudent);
System.out.println("===============");
//调用小学生的方法
XStudent xStudent = new XStudent();
//给中学生的父类的属性赋值
xStudent.setName("小学生");
//输出作文的Xie方法实参值为xStudent(被调用的小学生类)
zuoWen.Xie(xStudent);
}
}
6.内部类及OOP实战
◆内部类就是在-个类的内部在定义-个类，比如，A类中定义-个B类,那么B类相对A类来说就称为内部类,而A类相对B类来说就是外部类了。
◆1.成员内部类
◆2.静态内部类
◆3.局部内部类
◆4.匿名内部类
1.成员内部类、局部内部类
package java_jichu.mianxiangduixiang.demo12;
public class Outer {
// 一
// private int id=10;
// public void out(){
// System.out.println("这是外部类的方法");
// }
// (1)
// public class Inner{
// public void in(){
// System.out.println("这是内部类的方法");
// }
// (2)
// //获得外部类的私有属性
// public void getID(){
// System.out.println(id);
// }
// }
// 三
//局部内部类
public void method(){
class Inner{
public void in(){
}
}
}
}
//二
//一个java类中可以有多个class类，但只能有一个public class
//class A{
// public static void main(String[] args) {
//
// }
//}
2.匿名内部类
package java_jichu.mianxiangduixiang.demo12;
public class Test {
public static void main(String[] args) {
//没有名字初始化类，不用实例保存到变量中
new Apple().eat();
new UserService(){//UserService userService new UserService() 必须要重写里面的方法
@Override
public void hello() {
}
};
}
}
class Apple{
public void eat(){
System.out.println("1");
}
}
interface UserService{
void hello();
}
package java_se.java_jichu.zuoye_8_9.demo4;
import java_se.java_jichu.zuoye_8_9.demo3.San;
public class TestZW {
public static void main(String[] args) {
//调用作文的方法
ZuoWen zuoWen = new ZuoWen();
//调用中学生的方法
ZStudent zStudent = new ZStudent();
//给中学生的父类的属性赋值
zStudent.setName("中学生");
//输出作文的Xie方法实参值为zStudent(被调用的中学生类)
zuoWen.Xie(zStudent);
System.out.println("===============");
//调用小学生的方法
XStudent xStudent = new XStudent();
//给中学生的父类的属性赋值
xStudent.setName("小学生");
//输出作文的Xie方法实参值为xStudent(被调用的小学生类)
zuoWen.Xie(xStudent);
}
}
6.内部类及OOP实战
◆内部类就是在-个类的内部在定义-个类，比如，A类中定义-个B类,那么B类相对A类来说就称为内部类,而A类相对B类来说就是外部类了。
◆1.成员内部类
◆2.静态内部类
◆3.局部内部类
◆4.匿名内部类
1.成员内部类、局部内部类
package java_jichu.mianxiangduixiang.demo12;
public class Outer {
// 一
// private int id=10;
// public void out(){
// System.out.println("这是外部类的方法");
// }
// (1)
// public class Inner{
// public void in(){
// System.out.println("这是内部类的方法");
// }
// (2)
// //获得外部类的私有属性
// public void getID(){
// System.out.println(id);
// }
// }
// 三
//局部内部类
public void method(){
class Inner{
public void in(){
}
}
}
}
//二
//一个java类中可以有多个class类，但只能有一个public class
//class A{
// public static void main(String[] args) {
//
// }
//}
2.匿名内部类
package java_jichu.mianxiangduixiang.demo12;
public class Test {
public static void main(String[] args) {
//没有名字初始化类，不用实例保存到变量中
new Apple().eat();
new UserService(){//UserService userService new UserService() 必须要重写里面的方法
@Override
public void hello() {
}
};
}
}
class Apple{
public void eat(){
System.out.println("1");
}
}
interface UserService{
void hello();
}
◆内部类就是在-个类的内部在定义-个类，比如，A类中定义-个B类,那么B类相对A类来说就称为内部类,而A类相对B类来说就是外部类了。
◆1.成员内部类
◆2.静态内部类
◆3.局部内部类
◆4.匿名内部类
package java_jichu.mianxiangduixiang.demo12;
public class Outer {
// 一
// private int id=10;
// public void out(){
// System.out.println("这是外部类的方法");
// }
// (1)
// public class Inner{
// public void in(){
// System.out.println("这是内部类的方法");
// }
// (2)
// //获得外部类的私有属性
// public void getID(){
// System.out.println(id);
// }
// }
// 三
//局部内部类
public void method(){
class Inner{
public void in(){
}
}
}
}
//二
//一个java类中可以有多个class类，但只能有一个public class
//class A{
// public static void main(String[] args) {
//
// }
//}
