匿名对象相关知识点:
匿名对象是指创建对象时,只有创建对象的语句,却没有把对象地址值赋值给某个变量。
创建一个普通对象:引用类型变量可以反复使用
Person p = new Person();
P.eat();
创建一个匿名对象:没有引用变量,只能使一次
new Person(); 调用:new Person().eat();
int number=new Scanner( System.in).nextInt;
匿名对象的特点:
1、匿名方法可以直接使用,没有变量名。
例如:new Person().eat() //eat方法被一个没有名字的Person对象调用了。
2、匿名方法在没有指定其引用变量时,只能使用一次
例如:new Person().eat(); 创建一个匿名对象,调用eat方法
new Person().eat(); 想再次调用eat方法,重新创建了一个匿名对象
3、匿名方法可以作为方法接收的参数、方法返回值使用
参数传递
method(new Person());
public static void method(Person p){
p.eat();
}
方法返回值传递
Person p1=method();
p1.eat();
public static Person method( ){
Person p=new Person;
return p;
}
内部类的相关知识点:
什么是内部类:将类写在其他类的内部,可以写在其他类的成员位置和局部位置
注意事项:内部类编译好了也是以.class文件的形式存在的
分类:1、成员内部类 2、局部内部类
成员内部类:
注意事项:成员内部类也可以使用成员修饰符public、static。。。,也是个类,可以继承,可以实现接口
就近访问原则在内部类中同样适用哦~(下面代码省略测试类哦~)
public class Outer {//外部类
int i =1;
class Inner { //内部类
int i=2;
public void inner() {
int i=3;
System.out.println(i);//此处打印3(就近原则)
System.out.println(this.i); //此处打印2
System.out.println(Outer.this.i); //此处打印1
}
}
}
调用:1、内部类可以使用外部类的成员,包括私有属性(两个都是以同级的关系存在的)
2、外部类要使用内部类的成员,必须要先创建对象
- 定义格式
class 外部类 {
修饰符 class 内部类 {
//其他代码
}
}
- 访问方式(重点)
外部类名.内部类名 变量名 = new 外部类名().new 内部类名();
对象.内部类方法();
- 成员内部类代码演示
class Body {//外部类,身体
private boolean life= true; //生命状态
public class Heart { //内部类,心脏
public void jump() {
System.out.println("心脏噗通噗通的跳")
System.out.println("生命状态" + life); //访问外部类成员变量
}
}
}
访问内部类:
public static void main(String[] args) {
//创建内部类对象
Body.Heart bh = new Body().new Heart();
//调用内部类中的方法
bh.jump();
局部内部类
就是把类写在方法里面
- 定义格式
class 外部类 {
修饰符 返回值类型 方法名(参数) {
class 内部类 {
//其他代码
}
}
}
- 访问方式(重点)
在外部类方法中,创建内部类对象,进行访问
- 代码演示
定义类
class Party {//外部类,聚会
public void puffBall(){// 吹气球方法
class Ball {// 内部类,气球
public void puff(){
System.out.println("气球膨胀了");
}
}
//创建内部类对象,调用puff方法
new Ball().puff();//这条代码等同于 Ball in=new Ball(); in.puff();
}
}
访问内部类
public static void main(String[] args) {
//创建外部类对象
Party p = new Party();
//调用外部类中的puffBall方法
p.puffBall();
}
内部类的实际使用——匿名内部类
作用:匿名内部类是创建某个类型子类对象的快捷方式(减少代码)
使用前提:继承或实现一个接口
定义匿名内部类有两个含义:1、临时定义某一个类型的子类。2、定义后即刻创建刚刚定义的这个子类的对象
格式:new 父类或接口(){//进行方法重写};
代码演示:
class XXX implements Smoking{ //实现类,实现接口 重写接口抽象方法,创建实现类对象
public void smoking(){
}
}
XXX x=new XXX();
x.smoking();
测试类
new Smoking(){
public void smoking(){
System.out.println("人在吸烟");
}
}.smoking();
两个代码是等价的,测试类中的代码如果没有“.smoking”代码将输出为空
使用匿名对象的方式,将定义子类与创建子类对象两个步骤由一个格式一次完成,。虽然是两个步骤,但是两个步骤是连在一起完成的。
运用多态的方式,实现匿名内部类:
public static abstract Animal{
public abstract void eat();
public abstract void sleep();
}
测试类:
public class Test{
public static void main(String[] args) {
Animal a =new Animal(){//运用多态的方式,父类的引用指向子类的引用
public void eat(){
System.out.println("在吃饭");
}
public void sleep(){
System.out.println("在睡觉");
}
};
a.eat();
a.sleep();
}
}
输出的结果为:在吃饭
在睡觉
访问修饰符相关知识点:
- 权限修饰符: public : 公共的 protected: 受保护的 默认 private : 私有的
public protected 默认的 private
在当前类中 Y Y Y Y
同一包中的其他类 Y Y Y
不同包中的子类 Y Y
不同包中的其他类 Y
归纳一下:在日常开发过程中,编写的类、方法、成员变量的访问
- 要想仅能在本类中访问使用private修饰;
- 要想本包中的类都可以访问不加修饰符即可;
- 要想本包中的类与其他包中的子类可以访问使用protected修饰
- 受保护的权限,只能是子类的里面!!!调用父类的受保护成员
- 要想所有包中的所有类都可以访问使用public修饰。
- 注意:如果类用public修饰,则类名必须与文件名相同。一个文件中只能有一个public修饰的类。
代码块相关知识点:
分类:1、局部代码块 2、构造代码块(构造代码块、静态代码块)
局部代码块(限制生命周期或者是作用域):局部代码块是定义在方法或语句中
特点:
- 以”{}”划定的代码区域,此时只需要关注作用域的不同即可
- 方法和类都是以代码块的方式划定边界的
class Demo{
public static void main(String[] args) {
{
int x = 1;
System.out.println("普通代码块" + x);
}
int x = 99;
System.out.println("代码块之外" + x);
}
}
结果:
普通代码块1
代码块之外99
构造代码块:构造代码块是定义在类中成员位置的代码块
特点:
- 优先于构造方法执行,构造代码块用于执行所有对象均需要的初始化动作
- 每创建一个对象均会执行一次构造代码块。
public class Person {
private String name;
private int age;
//构造代码块
{
System.out.println("构造代码块执行了");
}
Person(){
System.out.println("Person无参数的构造函数执行");
}
Person(int age){
this.age = age;
System.out.println("Person(age)参数的构造函数执行");
}
}
class PersonDemo{
public static void main(String[] args) {
Person p = new Person();
Person p1 = new Person(23);
}
构造代码块优先被执行
静态代码块: 静态代码块是定义在成员位置,使用static修饰的代码块。
特点:
- 它优先于主方法执行、优先于构造代码块执行,当以任意形式第一次使用到该类时执行。
- 该类不管创建多少对象,静态代码块只执行一次。
- 可用于给静态变量赋值,用来给类进行初始化。
public class Person {
private String name;
private int age;
//静态代码块
static{
System.out.println("静态代码块执行了");
}
}
静态代码块被优先执行
注意:(非常重要)(静态代码块>构造代码块>构造方法)
静态代码块,只执行一次
构造代码块,new一次,执行一次,优先于构造方法
构造方法,new一次,就执行一次