11-7
1.构造方法:
类构造对象时所用的方法,主要用来实例化对象;
特点:
1.)方法名和类名相同;
2.)没有具体返回值;
3.)连void都没有;
public class Student {
public Student(){}
}目的:就是为了类的成员相关数据进行初始化;
初始化的两种方式:
1.)系统默认初始化(空值null)
2.)显示初始化
构造方法的注意事项
1.)书写标准类的时候,没有给出任何的构造方法,系统会默认给出一个无参构造方法
2.)如果提供了一个有参构造方法,系统就不会提供构造方法;
3.)构造方法时可以重载的;
无参构造方法
public Student(){
System.out.println("这是无参构造方法");有参构造方法
//有参构造方法:带上参数类型及参数名
public Student(String name){
System.out.println(name);2.成员变量(什么时候将变量定义为成员变量)
变量定义的时候:如果能够描述这个事物(类)的属性----定义成员变量
public class Student {
//成员变量:描述事物的属性,比如学生的属性:姓名,年龄...
String name;
int age;
}3.一个类中的成员(使用有参构造方法也可以完成成员变量的赋值)
一个标准类:
成员变量:属性私有化
成员方法:setXXX(xx)/getXXX(xx)
构造方法:无参构造方法永远给出来
有参构造方法(自己定义)
4.static关键字
本身含义:共享共用;
被static修饰的变量或者方法---->随着类的加载而优先与对象;
访问方式:
类名.变量名;
类名.方法名;
一般说的成员的东西:
都是非静态的,需要对象来访问;
特点:
1.)被静态修饰的随着类的加载而加载,优先于对象存在;
2.)不能和this共存;
3.)本身的含义就是共享,共用;可以多个对象共享共用;
//非静态的成员变量
public int num=10;
//静态的成员变量
public static int num1=20;
//非静态的成员方法
public void study(){
System.out.println();
}
//静态的成员方法
public static void study1(){
System.out.println();
}
5.代码块---{}(重点去掌握:代码块的优先级,静态代码块,构造代码块,构造方法)
代码块:使用{}括起来的内容;
分类:
1.)局部代码块:就是在方法定义中去使用{}
{}作用:就是限定局部变量的生命周期;
2.)构造代码块:在类的成员位置定义的{}
特点:在执行构造方法之前,如果类中有构造代码块,优先执行构造代码块;
作用:可以给类的成员的数据进行初始化
只要执行构造方法,如果存在构造代码块,它必须先执行,然后才是构造方法
3.静态代码块
类就加载一次,静态代码块也就执行一次;
格式:static{}
静态代码块 执行一次完毕
构造代码块:每次执行构造方法之前,如果代码中有构造代码块,优先执行构造代码块;
优先级:
静态代码块>构造代码块>构造方法
6.成员变量和静态变量的区别
1.)存储位置不同
成员变量:堆内存中
静态变量:static静态区中;
2.)生命周期不同
成员变量:不会立即被回收;
静态变量:随着类的加载而存在,随着类的加载完毕而消失;
3.)初始化不同
成员变量:可以不初始化,存在默认初始化,通过setXXX(xx)或者有参构造方法显示初始化;
静态变量:可以不初始化,或者直接初始化,也可以通过类名.变量名=赋值;
4.)访问方式不同
成员变量:创建对象-------类名 对象名=new 类名();
对象名.成员变量
静态变量:不推荐使用对象名来访问,使用 类名.变量名
11-8
继承(重点)
概念:多个类的共性内容抽取出来到独立的类中,让其与其他类产生关系,这种关系就叫继承;
关键字:extends
格式:
class 子类 extends 父类{}
特点:只支持单继承不支持多继承,但是可以层层继承;
好处:
1.)可以提高代码的复用;
2.)可以提高代码的维护性;
3.)类与类产生的继承关系,是"多态的前提"
弊端:
具有局限性,继承了一个类,可以将这个类里面的所有非私有的方法继承过来,有的功能不需要,不能为了使用类的部分功能,去使用继承;
使用继承的时机:当类A是类B的一种;
继承的注意事项:
1.)子类继承父类,继承父类的非私有的成员,私有的成员,可以简介访问;
2.)子类继承父类,构造方法是不能继承的,通过一个关键字来访问 super()
继承的构造方法访问问题:
子类继承父类,子类的构造方法不能继承父类的构造方法,但是可以通过关键字super访问;
super();
super(XXX)
this 访问本类中的构造方法
super 访问父类中的 构造方法
继承的成员变量访问问题
1.)子类继承父类,如果子类和父类的成员变量名称不一致(分别访问即可)
2.)子类继承父类,子类和父类的成员变量名称一致(采用就近原则)
子类局部位置--->子类成员位置--->父类
继承的成员方法访问问题
1.)子类继承父类,成员方法名称不一致,分别调用既可;
2.)如果成员方法名一样,系统默认子类将父类的方法覆盖,直接访问子类的功能;
继承中的相关面试题
this和super的区别?
this:代表的当前类对象地址值的引用;
super:代表父类的空间表示(父类的对象的地址值引用)
使用不一样:
this.变量名:访问本类的成员变量
super.变量名:访问父类的成员变量
this.方法名():访问本类的成员方法
super.方法名:访问父类的成员方法
this():访问本类的无参构造方法
this(xx):访问本类的有参构造方法
super():访问父类的无参构造方法
super(xx):访问父类的有参构造方法
方法重写Override和方法重载Overload的区别?
方法重载Overload:
定义方法的时候,多个方法的方法名相同,参数列表不同,与返回值和i无关
参数列表不同:
1.)参数个数
2.)参数类型
3.)先后类型顺序
方法重写Override
在继承中,子类出现了和父类一摸一样的方法声明,子类会将父类的方法覆盖,使用子类的一些自己功能;
重写的时候,要保证访问权限足够大;
class Fu{
public void show(){}
}
class Zi extends Fu{
void show(){ //不行,访问权限问题:要么跟父类的一模一样,要么永远带上public
}
}final关键字
final:本身表示无终的,无法更改的,状态修饰符
1.)final修饰的类是最终类,该类不能被继承
2.)final修饰的变量是----->一个自定义常量,而且必须赋初始值
编译时期常量:final修饰的基本数据类型,其值不能被改变
运行时期常量:final修饰的引用类型数据都需要加载,地址值不能改变
final修饰的方法不能重写
11-9
多态
概念:
宏观的:一个事物在不同时刻体现的不同形态
微观的:具体对象在内存中的变化
前提条件:
1.)必须有继承;
2.)存在方法重写;
3.)父类引用指向子类对象;
Fu fu = new Zi;
//向上转型多态的成员访问特点:
1.)访问成员变量:编译看左,运行看左;
2.)访问成员方法(重写的放法):编译看左,运行看右;
3.)访问静态的方法:算不上重写,跟类相关的,编译看左,运行看左;(静态方法不能被重写);
4.)访问构造方法:分层初始化,先执行父类初始化,再执行子类初始化;
多态的弊端
不能访问子类的特有功能:
多态的格式:
Fu fu = new Zi;
//向上转型解决方案:
1.)创建具体的子类对象
(不推荐,需要重新在堆内存中开辟空间,消耗内存空间)
2.)向下转型
Zi z=(Zi) fu;//符合强转的语法
z.子类特有的功能不需要单独去开辟堆内存空间;
针对多态的向下转型,前提必须有向上转型(父类引用指向子类对象)
运行时期异常--->java.lang.ClassCastException :类转换异常 一般都出现多态里面向下转型使用不当就会造成这个异常出现多态的好处
1.)提高代码的复用性,由继承保证的;
2.)提高代码的扩展性,由多态保证,父类引用指向子类对象;
抽象类
概念:
一个事物的某个行为应该具体的事物具体体现,将这个事物顶层次(父类)可以定义为抽象
举例
动物事物---都具备吃和睡的行为,只有见到具体的事物才具备的具体行为,"猫","狗"吃和睡不一样,应该在具体事物中给出具体的体系,.那么在动物事物中,仅仅一个声明!(没有方法体)
//抽象类的定义
abstract class 类名 {}有抽象方法的类一定是抽象类,抽象类不一定都是抽象方法(重点)
//抽象方法的格式
权限修饰符 abstract 返回值类型 方法名(空参/无参);抽象类的特点
1.)抽象类不能实例化;
2.)抽象类的子类如果也是抽象类,不能实例化,一定会提供最具体的子类,完成实例化(创建对象)
抽象的父亲类 对象名 =new 具体的子类名(); 抽象类多态抽象类的成员特点
成员变量:既可以是变量也可以是自定义常量
成员方法:抽象类中既可以有抽象方法也可以有非抽象方法
构造方法:
既可以定义无参/有参构造方法....
存在抽象类多态,有继承关系,初始化的时候,构造方法---分层初始化--->先父类初始化,子类初始化
面试题
如果一个类没有任何抽象方法,还要将这个类定义为抽象类的意义?
意义:就是不能让他new,它如何实例化呢?肯定有具体的子类,进行抽象类多态来操作...
abstract和那些关键字冲突?
不能和private一块用:被private修饰的成员需要在当前类进行访问,
不能和final一块用:被static修饰的成员方法,不能被重写,而abstract抽象方法,必须强制子类重写;
不能和static一块用:被static修饰的成员方法,算不上重写
abstract关键字的应用范围:
1.)定义类---抽象类
2.)定义方法---抽象方法;
子类继承父类,子类重写父类的抽象方法,必须保证访问权限足够大,要么加public,要么跟父类的方法保持一致;
接口
定义:
体现的是这个事物本身不具备的功能,额外的功能;
interface 接口名{}接口的特点
1.)接口的方法不能有方法体,只能是抽象方法,而且隐藏public abstract;
2.)接口不能实例化(不能创建对象)
3.)如果接口的是实现类是一个抽象类,肯定有一个具体的接口的实现类来进行new对象
接口名 对象名 =new 具体的子实现类(); 接口多态
开发中定义接口的子实现类(子类)名
class 接口名+Impl implments(实现) 接口名{}接口和抽象类的区别
1.)成员的区别
抽象类:
成员变量:既可以是常量,也可以是变量
成员方法:既可以是抽象方法,也可以是非抽象方法;
构造方法:无参/有参都存在
接口:
成员变量:只能是常量
成员方法:只能是抽象方法
构造方法:没有,需要借助子类实现实例化
2.)关系的区别
类与类:可能是一些抽象类,继承关系,只支持单继承,不支持多继承,但是可以多层继承;
类与接口:实现关系
一个类继承另一个类(可能是一个抽象了类)的同时,还可以实现多个接口
接口与接口:继承关系
支持单继承,也可以多继承
3.)设计理念的区别
抽象类---不能实例化
需要通过具体的子类实现类(继承关系)
接口----不能实例化
需要通过具体的子实现类进行实例化(实现关系)----事物的一种额外功能;
11-10
package在开发中的应用含义
package包---本质就是文件夹(目录)
程序员在编写代码存储的地址
包---->开发中 (公司域名反写,多个包中间.隔开)
公司域名
com.qf
本质
com文件夹
qf文件夹
xx.java
包----为了维护代码结构的(代码分层)
com.qf.pojo/domain/entity: 存放Java实体类(满足JavaBean规范:)
1)这个类是具体类
2)属性私有化 (属性必须全部字母小写)
3)对外提供公共的setXXX(xx)/getXXX()
关于类与类,类与接口,接口与接口的关系
java中最基本单元就是类! ---- Java中只支持单继承(类和类)
类与类: 只支持单继承,不支持多继承,但是多层继承
类与接口:是实现关系,一个类继承另一个类的同时,可以实现多个接口!
class 子类名 extends 父类名 implements 接口1,接口2....{}
接口与接口:(继承关系)----------->集合:Collection 接口---->List子接口 Set子接口
Map接口----------->HashMap TreeMap
不仅可以单继承,也可以多继承多层继承
class GrandFather{}
class Father extends GrandFather{}
class Son extends Father{}形式参数问题
方法形式参数如果引用类型
数组---->需要传递数组对象
类
具体类----->实际参数,需要传递当前类对象
抽象类---->抽象类不能实例化,实际参数传递该抽象类的子类对象 (抽象类多态)
接口 ----->接口不能实例化,实际参数需要传递该接口的子实现类对象(接口多态)
1.)具体类--->实际参数,需要传递当前类对象
//学生类
class Student{
public void studyJavaEE(){
System.out.println("学生正在学习JavaEE");
}
}
//定义一个类
class StudentDemo{
public void method(Student student){//形式参数引用类型:具体类 ---->实际参数需要该Student类的具体对象
student.studyJavaEE(); //具体的对象(空间地址值)调用成员方法
}
}
//测试类
public class ArgsDemo {
public static void main(String[] args) {
//需要调用StudentDemo类中method方法
//1)需要创建StudentDemo类对象
StudentDemo sd = new StudentDemo() ;
//2)调用方法
Student s = new Student() ;
sd.method(s);
System.out.println("----------------------------------------");
//可以都匿名对象
new StudentDemo().method(new Student());
}
}
2.)抽象类--->抽象类不能实例化,实际参数传递该抽象类的子类(抽象类多态)
//抽象的人类
abstract class Person{
public void work(){
System.out.println("人都需要工作");
}
}
//定义一个PersonDemo类
class PersonDemo{
public void show(Person p){//形式参数一个引用类型:抽象类--->实际参数,需要传递抽象类的子类对象!(抽象类多态)
p.work() ;
}
}
//定义一个抽象类的子类(具体类,否则还不能实例化)
//工人类
class Worker extends Person{
@Override
public void work() {
System.out.println("爱敲代码,爱生活,爱高圆圆!");
}
}
//测试类
public class ArgsDemo2 {
public static void main(String[] args) {
//调用PersonDemo类的show方法
//1)创建PersonDemo类对象
PersonDemo pd = new PersonDemo() ;
//2)调用方法
//Person p = new Person() ; //抽象类不能实例化(不能创建对象)
// pd.show(p);
//抽象类多态
Person person = new Worker() ;
pd.show(person);
System.out.println("------------------------");
//匿名对象
new PersonDemo().show(new Worker());
}
}3.)接口--->接口不能实例化,实际参数需要传递该接口的子实现类对象(接口多态)
//定义一个接口
interface Mary{
//结婚
public abstract void mary() ;
}
//定义MaryDemo类
class MaryDemo{
public void function(Mary mary){//形式参数是引用类型,接口类型---实际参数?需要接口的子实现类对象(接口多态)
mary.mary();
}
}
//需要的接口的子实现类
class You implements Mary{
@Override
public void mary() {
System.out.println("结婚了,很开心...");
}
}
//测试类
public class ArgsDemo3 {
public static void main(String[] args) {
//需要调用MaryDemo类中function方法
//1)创建MaryDemo类对象
MaryDemo md = new MaryDemo() ;
//2)调用方法
/* Mary mary = new Mary(); //接口也是抽象的,不能实例化
md.function(mary);*/
Mary mary = new You() ; //接口多态
md.function(mary) ;
System.out.println("----------------------------------") ;
//匿名对象
new MaryDemo().function(new You());
}
}
返回值问题
1.)具体类:需要返回的是当前具体类对象
//学生类
class Student{
public void sutdy(){
System.out.println("正在学习JavaSE之面向对象");
}
}
//定义一个StudentDemo类
class StudentDemo{
/* public int add(int a,int b){
return a+b ;
}*/
public Student getStudent(){
//?
//如何返回?
//如果方法的返回值是一个引用类型:具体类,需要返回当前类的对象!
//Student s = new Student() ;
// return s ;
return new Student(); //匿名对象
}
}
//测试类
public class ReturnDemo {
public static void main(String[] args) {
//调用StudentDemo类中的getStuent方法
//1)创建对象
StudentDemo sd = new StudentDemo() ;
//2)调用方法
Student student = sd.getStudent(); //sd.getStudent() 逻辑---创建一个学生
//本质就是Student student = new Student() ;
student.sutdy();
System.out.println("-----------------------------------------") ;
//匿名对象
//链式编程(自己玩)
new StudentDemo().getStudent().sutdy();
}
}
2.)抽象类:需要返回的是当前抽象类的子类对象(抽象类多态)
//抽象类
abstract class Person{
public void work(){
System.out.println("人都需要工作");
}
}
//定义一个PersonDemo
class PersonDemo{
public Person getPerson(){
// Person p = new Person() ;
//return p;
//return new Person() ;
//抽象类不能new,可以通过抽象类的子类进行实例化
//抽象类多态
// Person p = new Programmer() ;
// return p;
return new Programmer() ;
}
}
//定义出现抽象类的子类
class Programmer extends Person{
@Override
public void work() {
System.out.println("程序员日日夜夜coding...");
}
}
//测试类
public class ReturnDemo2 {
public static void main(String[] args) {
//调用PersonDemo的getPerson()
PersonDemo pd = new PersonDemo() ;
Person person = pd.getPerson();//方法的本质---Person person = new Programmer() ;
person.work() ;
System.out.println("----------------------------") ;
//匿名对象
new PersonDemo().getPerson().work();
}
}
3.)接口:需要返回的是接口的子实现类对象(接口多态)
//定义一个接口
interface Love{
void love() ;
}
//有一个类LoveDemo
class LoveDemo{
//成员方法
public Love getInstance(){ //返回值是接口类型
// Love love = new Love() ; //接口不能实例化
//return love;
//方式1:
//接口多态:需要接口类型---返回接口的子实现类对象
// Love love = new LoveImpl() ;
//return love ;
//方式2:匿名对象
return new LoveImpl() ;
}
}
//需要有一个子实现类来实现接口
class LoveImpl implements Love{
@Override
public void love() {
System.out.println("爱生活,爱Java");
}
}
//测试类
public class ReturnDemo3 {
public static void main(String[] args) {
//调用LoveDemo里面的getInstance()方法
LoveDemo ld = new LoveDemo() ;
Love love = ld.getInstance(); //方法本质 --Love love = new LoveImpl() ;
love.love();
System.out.println("------------------------------------------") ;
//匿名对象
new LoveDemo().getInstance().love();
}
}
权限修饰符的应用范围
private:同一个包下的本类(范围最小)
默认修饰符:同一个包下的子类/同一个包下的无关类
protected(受保护的):不同包下的子类
public公共:不同包下的无关类
内部类(了解)
成员内部类---还可以static修饰符(记忆)
1.)静态的成员内部类只能外部类的静态成员!
2.)静态的成员内部类中无论是静态方法还是非静态方法:访问外部类的成员必须静态
3.)想直接通过外部类来访问静态成员内部类的成员信息,访问格式
外部类名.内部类名 对象名 = new 外部类名.内部类名()
//内部类----实际开发中(应用层面居多)
//内部类里面的一些访问方式(重点)
//属于设计层面(jdk源码里面会看到)
class Outer{
//成员内部类
class Inner{
}
}
class Outer{
public void show(){
//局部位置
class Inner{} //局部内部类
}
}
外部类如何直接访问成员内部类的成员?
格式:
外部类名.内部类名 对象名 = new 外部类名().new 内部类名() ;
对象名.成员内部类的成员;
外部类如何直接访问静态成员内部类的成员?
格式:
外部类名.内部类名 对象名 = new 外部类名.内部类名() ;
对象名.静态成员内部类的成员;
如果静态的成员内部类的成员方法也是静态的:
外部类名.内部类名.静态方法名() ;
静态的成员内部类里面的成员方法无论是静态还是非静态的访问外部类的成员必须为静态!
常用类
重要的几个类(凡是 类型转换都是重点)
Object
String (里面功能最多
转换
截取
替换
字典比较
)
StringBuffer(线程安全的类)
java.util.Date:日期类
String日期文本---->Date日期格式
基本类型四类八种---->八个引用类型(Inetger,Character)
BigDecimal:小数精确计算
System
11-11
局部内部类
1.局部内部类的面试题(局部内部类访问局部变量 jdk7以前必须加
入final)
局部内部类:
1)也可以访问外部类的成员包括私有
2)面试题:局部内部类访 访问它的成员方法里面的局部变量,局部变量有什么特点?(重点)
jdk7以前(包括jdk7):局部内部类访问局部变量的时候,局部变量必须使用final修饰,为什么?
局部变量它随着方法调用而存在,随着方法调用结束而消失,但是现在是通过局部对象调用它的成员方法还在使用这个
局部变量
局部变量必须为常量(加入final)---局部内部类对象不会立即消失,等待gc回收!
2.面试题2(补全代码)
//分别在控制态输出30,20,10
//外部类
class Outer2{
int num = 10 ;
//成员内部类
class Inner2{
int num = 20 ;
public void show(){
int num = 30 ;
//补全代码
System.out.println(num) ;
System.out.println(this.num); //访问自己本类的成员变量
//方式1
//System.out.println(new Outer2().num) ;
//方式2:外部类的this限定
System.out.println(Outer2.this.num);
}
}
}
//测试类
public class InnerClassTest {
public static void main(String[] args) {
Outer2.Inner2 oi = new Outer2().new Inner2() ;
oi.show();
}
}匿名内部类(重点)
匿名内部类: 没有名字的类
应用范围: 在局部位置中的(方法定义中或者声明上)
匿名内部类的格式:
new 类名或者一个接口名(){
重写方法(){
...
}
}
匿名内部类的本质:就是继承该类(抽象类)或者是实现类了该接口的子类对象!匿名内部类在开发中的使用场景:形式参数问题
抽象类
//抽象类
abstract class Person{
public abstract void work() ;
}
//定义PersonDemo类
class PersonDemo{
public void show(Person p){//引用类型--抽象类---需要抽象类子类对象
p.work();
}
}
//定义一个类(具体类),继承Person
class Progammer extends Person{
@Override
public void work() {
System.out.println("程序员日日夜夜敲代码...");
}
}
//测试类
public class ArgsDemo {
public static void main(String[] args) {
//调用PersonDemo类里面的show方法
PersonDemo pd = new PersonDemo() ;
//Person p = new Person() ;//抽象类不能new
//抽象类多态
Person p = new Progammer() ;
pd.show(p);
System.out.println("--------------------------------------") ;
//方式2:可以使用抽象类的匿名内部类
/**
* new 抽象类名(){
* 重写方法
* }
*/
pd.show(new Person() {
@Override
public void work() {
System.out.println("人都需要工作...");
}
});
}
}接口
//有一个接口
interface Mary{
public abstract void mary() ;//接口中有且仅有一个抽象方法,这个接口称为"函数式接口"
}
//定义一个类
class MaryDemo{
public void method(Mary mary){//需要使用接口多态,创建具体的子实现类对象
mary.mary();
}
}
//定义接口的子实现类实现这个接口
class You implements Mary{
@Override
public void mary() {
System.out.println("结婚了,很开心...");
}
}
//测试类
public class ArgsDemo2 {
public static void main(String[] args) {
//调用MaryDemo里面的method方法
MaryDemo md = new MaryDemo() ;
//接口多态
Mary mary = new You() ;
md.method(mary);
System.out.println("------------------------------------------");
//接口匿名内部类
md.method(new Mary() {
@Override
public void mary() {
System.out.println("要结婚了,很开心...");
}
});
System.out.println("-------------------------------------------");
//jdk8的一个新特性:拉姆达表达式 (针对函数式接口)
md.method(
//拉姆达表达式
()-> {
System.out.println("要结婚了,很开心...");
}
);
}
}
匿名内部在开发中的使用 :返回值问题
抽象类
//方法的返回值是一个抽象类,需要返回该抽象类的子类对象
abstract class Person{
public abstract void work() ;
}
class PersonDemo{
public Person show(){
//需要返回的抽象类的子类对象 (抽象类多态)
//Person p = new Worker() ;
// return p;
//return new Worker() ;
//抽象类的匿名内部类
return new Person(){
@Override
public void work() {
System.out.println("打工人爱工作,爱生活,爱美女");
}
};
}
}
//测试类
public class ReturnDemo {
public static void main(String[] args) {
//访问PersonDemo的show
PersonDemo pd = new PersonDemo() ;
Person person = pd.show(); //方法的本质---->new 子类名() ;
person.work() ;
}
}接口
//方法的返回值是一个接口,需要返回该接口的子实现类对象!
//接口
interface Inter{
void love() ;
}
//InterDemo类
class InterDemo{
public Inter function(){
//接口的匿名内部类
return new Inter() {
@Override
public void love() {
System.out.println("love Inter....");
}
};
//测试类
public class ReturnDemo2 {
public static void main(String[] args) {
//创建InterDemo对象
InterDemo id = new InterDemo() ;
Inter inter = id.function(); //方法本质--->创建接口子实现类对象
inter.love();
}
}
选择排序
//定义一个选择排序的方法
public static void printA(int arr[]){
for(int x=0;x<arr.length-1;x++){
for(int y=x+1;y<arr.length;y++){
if (arr[x]>arr[y]) {
int temp=arr[x];
arr[x]=arr[y];
arr[y]=temp;
}
}
}
}常用类之Object的getClass方法
表示所有的类的根类(超类或者父类),所有的类默认继承自Object,拥有这个类的所有非私有方法
在Java中获取一个类的字节码文件对象的方式有几种?
三种方式
public final Class getClass() 任意java对象调用getClass()
任意Java类型的class属性
Class类有一个静态方法 forName("包名.类名")
//四:补全代码
//给定下面代码,最终需要输出 "helloworld"
interface Inter{
void show() ;
}
class Outer{
//补全代码
/* public static Inter method(){
return new Inter() {
@Override
public void show() {
System.out.println("helloworld");
}
} */ ;
}
}
public class OuterTest {
public static void main(String[] args) {
Outer.method().show() ;
}
}
1466
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
