Java学习（匿名对象、内部类、包、import、代码块）

一、匿名对象

概念：匿名对象是指在创建对象时，只有创建的语句，却没有把对象地址值赋给某个变量。

特点：

（1）匿名对象直接使用，没有变量名。当做形参使用。

new Person().name="张三";

（2）匿名对象只能调用一次方法，再次调用相当于又创建了一个新的匿名对象

new Person().setName("小明");
System.out.println(new Person().getName());  //输出为空，因为又创建了一个新的匿名对象，跟上一个并没有关系

（3）作为返回值使用传递

public Person getPerson(){
        //Person p=new Person();    //这一步骤省略直接用匿名对象来做返回值
        //return p;
        return new Person();
    }

实例：

package com.oracel.demo03;
//匿名对象 自定义类
public class Person {
    private String name;
    private int age;
    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 boolean compare(Person p){
        return this.age==p.age;
    }
    //匿名对象作为返回值来传递
    public Person getPerson(){
        //Person p=new Person();
        //return p;
        return new Person();
    }
}

package com.oracel.demo03;
//测试类
public class Test {
    public static void main(String[] args){
        //有名对象
//        Person p=new Person();
//        p.setName("张三");
//        p.getName();
//        //匿名对象（只能调用一次方法）     new:创建   Person():对象  合起来就是创建对象
//        new Person().setName("阿莱");
//        System.out.println(new Person().getName());
//        //匿名对象当做形参传递
//        p.compare(new Person());
        //匿名对象的三个作用：1.调用一次方法2.当做形参传递3.作为返回值来传递
    }
}

二、内部类

概念：将类写在其他类的内部，可以写在其他类的成员位置或局部位置，称为内部类，而“其他类”则称为外部类。

什么时候会使用？

在描述一个事物时，若事物内部还包含有其他可能包含的事物，比如在描述汽车时，汽车内部还包含着发动机，则发动机就可以用内部类来描述。

格式：

class Car{                      //car      就是外部类
      class FaDongJi{        //fadongji    就是内部类
    }       
}                

内部类的分类：

内部类还可以分为成员内部类和局部内部类。成员内部类就是在成员位置的内部类，而局部内部类则是在局部方法内的内部类。

定义内部类时，就是一个正常定义类的过程，同样包含各种修饰符 、继承与实现关系等。在内部类中可以直接访问外部类的所有成员。

2.1成员内部类

定义格式：

 class 外部类名称{
    修饰词 class 内部类名称{
    }
}

访问方式：

外部类名称.内部类名称   变量名称=new 外部类名称().new 内部类名称();

Car.FaDongJi cf=new Car().new FaDongJi();

2.2局部内部类

定义格式：

class 外部类名称{
    public void method(){     //外部类的局部方法
           class 局部内部类名称{     //局部内部类
    
        }  
    }           
}        

访问方式：在外部类方法中创建局部内部类的对象，进行访问。

package com.oracel.demo03;

public class Jeep {
    public void show(){  //外部类的方法
        //局部内部类
        class gulu{
            public void method(){
                System.out.println("这是轱辘的方法");
            }
        }
        //局部类访问方法：在外部类方法中，创建内部类对象，进行访问
        gulu g=new gulu();    //内部类的对象
        g.method();
    }
}

//在main方法中，创建外部类对象，调用局部方法，就可以访问局部内部类了
public class demo01{
     public static void main(String[] args){
            Jeep j=new Jeep();
            j.gulu();    

    }   
}    

 内部类的实际应用---匿名内部类

概念：最常用到的内部类就是匿名内部类，它是局部内部类的一种。

定义的匿名内部类有两种含义：

（1）临时定义某一指定类型的子类

（2）定义后即刻创建刚刚定义的这个子类的对象

 作用与格式：

 作用：匿名内部类是创建某个类型子类对象的快捷方式。

格式：

new 父类或接口（）{
   //进行方法重写   
};

练习题：编写一个抽象类Phone,两个抽象方法,call()  sendMessage()
   　　　两个子类OldPhone 和 NewPhone , 其中NewPhone想添加一个玩游戏的功能.
   　　　请根据接口的思想实现,并用匿名内部类的方式调用玩游戏的功能.

//父类
package com.oracel.homework;

public abstract class Phone {
     public abstract void call();
     public abstract void sendMessage();
}

//旧手机子类
package com.oracel.homework;

public class OldPhone extends Phone{
    public void call() {
        System.out.println("旧手机打电话");
    }
    public void sendMessage() {
        System.out.println("旧手机发短信");
    }

}

//接口：玩游戏
package com.oracel.homework;

public interface PlayGame{
    public abstract void playgames();
}

//新手机子类
package com.oracel.homework;

public class NewPhone extends Phone implements PlayGame{
    public void call() {
        System.out.println("新手机打电话");
    }
    public void sendMessage() {
        System.out.println("新手机发短信");
    }
    public void playgames(){
        
    }
}

 //测试类
package com.oracel.homework;

public class Test {

    public static void main(String[] args) {
        new OldPhone().call();
        new OldPhone().sendMessage();
        new NewPhone().call();
        new NewPhone().sendMessage();
                //用匿名内部类   重写方法  输出方法
        new NewPhone(){
            public void playgames(){
                System.out.println("新手机玩游戏");
            }
        }.playgames();

    }

}

 三、包的声明和格式

概念：java的包，其实就是我们电脑系统中的文件夹，包里存放的是类文件。

当类文件很多的时候，通常我们会采用多个包进行存放管理他们，这种方式称为分包管理。

在项目中，我们将相同功能的类放到一个包中，方便管理。并且日常项目的分工也是以包作为边界。

类中声明的包必须与实际class文件所在的文件夹情况相一致，即类声明在a包下，则生成的.class文件必须在a文件夹下，否则，程序运行时会找不到类。

 声明格式：

 通常使用公司网址反写，可以有多层包，包名采用全部小写字母，多层包之间用”.”连接

package  包名.包名.包名....；

 如：Oracle.com包名反写为com.oracle

注意：包的声明，必须在有效代码的第一行!!!!!!!!

 包的访问：

在访问类时，为了能够找到该类，必须使用含有包名的类全名（包名.类名）。

//包名.包名….类名
     java.util.Scanner
     java.util.Random
    com.oracle.Demo
//带有包的类，创建对象格式：包名.类名 变量名 = new包名.类名();
     com.oracle.Demo d = new com.oracle.Demo();

前提：包的访问与访问权限密切相关，这里以一般情况来说，即类用public修饰的情况。

类的简化访问：

当我们要使用一个类时，这个类与当前程序在同一个包中（即同一个文件夹中），或者这个类是java.lang包中的类时通常可以省略掉包名，直接使用该类。

Person p=new Person();

  当我们要使用的类，与当前程序不在同一个包中（即不同文件夹中），要访问的类必须用public修饰才可访问。

package com.oracle02;
public class Person {}

 四、import导包

概念： 我们每次使用类时，都需要写很长的包名。很麻烦，我们可以通过import导包的方式来简化。

　　　　可以通过导包的方式使用该类，可以避免使用全类名编写（即，包类.类名）。

 格式：

　　import     包名.类名；

注意： import导包代码书写的位置：在声明包package后，定义所有类class前，使用导包import包名.包名.类名;

 五、访问修饰符

 Java中提供了四中访问权限修饰符：

public        protected      default    private

下图为访问能力：

总结：

（1） 要想仅能在本类中访问使用private修饰；

（2）要想本包中的类都可以访问不加修饰符即可

（3）要想本包中的类与其他包中的子类可以访问使用protected修饰

（4）要想所有包中的所有类都可以访问使用public修饰

 注意：如果类用public修饰，则类名必须与文件名相同。一个文件中只能有一个public修饰的类。

 六、代码块

1.局部代码块

定义：局部代码块是定义在方法或语句中

特点：

（1）.以”{}”划定的代码区域，此时只需要关注作用域的不同即可

（2）.方法和类都是以代码块的方式划定边界的

2.构造方法块

构造代码块是定义在类中成员位置的代码块

特点：

（1）.优先于构造方法执行，构造代码块用于执行所有对象均需要的初始化动作

 

（2）.每创建一个对象均会执行一次构造代码块

3.静态代码块

定义：静态代码块是定义在成员位置，使用static修饰的代码块。

特点：

（1）.  它优先于主方法执行、优先于构造代码块执行，当以任意形式第一次使用到该类时执行。

 

（2）.  该类第一次创建对象时执行，该类不管创建多少对象，静态代码块只执行一次。

（3）.可用于给静态变量赋值，用来给类进行初始化

 

练习题：

package com.oracel.demo03;
//匿名对象 自定义类
public class Person {
    private String name;
    private int age;
    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 boolean compare(Person p){
        return this.age==p.age;
    }
    //匿名对象作为返回值来传递
    public Person getPerson(){
        //Person p=new Person();
        //return p;
        return new Person();
    }
}