zoukankan      html  css  js  c++  java
  • 匿名对象,内部类,包,访问修饰符,代码块

          匿名对象的概念

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

    1.1      匿名对象的特点

    l  创建匿名对象直接使用,没有变量名。

    new Person().eat()  //eat方法被一个没有名字的Person对象调用了。

    l  匿名对象在没有指定其引用变量时,只能使用一次。

    new Person().eat(); 创建一个匿名对象,调用eat方法
    new Person().eat(); 想再次调用eat方法,重新创建了一个匿名对象

    l  匿名对象可以作为方法接收的参数、方法返回值使用

    class Demo {
        public static Person getPerson(){
            //普通方式
            //Person p = new Person();    
            //return p;
            
            //匿名对象作为方法返回值
            return new Person(); 
        }
        
        public static void method(Person p){}
    }
    
    class Test {
        public static void main(String[] args) {
            //调用getPerson方法,得到一个Person对象
            Person person = Demo.getPerson();
            
            //调用method方法
            Demo.method(person);
            //匿名对象作为方法接收的参数
            Demo.method(new Person());
        }
    }

         内部类

    1      内部类概念

    l  什么是内部类

    将类写在其他类的内部,可以写在其他类的成员位置和局部位置,这时写在其他类内部的类就称为内部类。其他类也称为外部类。

    l  什么时候使用内部类

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

    class 汽车 { //外部类
        class 发动机 { //内部类
    
    }
    }

    l  内部类的分类

    内部类分为成员内部类与局部内部类。

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

    2      成员内部类

    成员内部类,定义在外部类中的成员位置。与类中的成员变量相似,可通过外部类对象进行访问

    l  定义格式

    class 外部类 { 
        修饰符 class 内部类 {
            //其他代码
    }
    }

    l  访问方式

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

    l  成员内部类代码演示

    定义类

    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();
    }

    3      局部内部类

    局部内部类,定义在外部类方法中的局部位置。与访问方法中的局部变量相似,可通过调用方法进行访问

    l  定义格式

    class 外部类 { 
        修饰符 返回值类型 方法名(参数) {
    class 内部类 {
    //其他代码
    }
    }
    }

    l  访问方式

    在外部类方法中,创建内部类对象,进行访问

    l  局部内部类代码演示

    定义类

    class Party {//外部类,聚会
        public void puffBall(){// 吹气球方法
            class Ball {// 内部类,气球
                  public void puff(){
         System.out.println("气球膨胀了");
    }
    }
    //创建内部类对象,调用puff方法
    new Ball().puff();
    }
    }

    访问内部类

    public static void main(String[] args) {
        //创建外部类对象
        Party p = new Party();
        //调用外部类中的puffBall方法
        p.puffBall();
    }

       匿名内部类概念

    内部类是为了应对更为复杂的类间关系。查看源代码中会涉及到,而在日常业务中很难遇到,这里不做赘述。

    最常用到的内部类就是匿名内部类,它是局部内部类的一种。

    定义的匿名内部类有两个含义:

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

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

        定义匿名内部类的作用与格式

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

    格式:

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

    l  代码演示

    //已经存在的父类:
    public abstract class Person{
        public abstract void eat();
    }
    //定义并创建该父类的子类对象,并用多态的方式赋值给父类引用变量
    Person  p = new Person(){
        public void eat() {
            System.out.println(“我吃了”);
    }
    };
    //调用eat方p.eat();

    使用匿名对象的方式,将定义子类与创建子类对象两个步骤由一个格式一次完成,。虽然是两个步骤,但是两个步骤是连在一起完成的。

    匿名内部类如果不定义变量引用,则也是匿名对象。代码如下:

    new Person(){
        public void eat() {
            System.out.println(“我吃了”);
    }
    }.eat();

      包的声明与访问      

    1      包的声明格式

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

             类中包的声明格式:

    package 包名.包名.包名…;

    如:Oracle网址oracle.com那么网址反写就为com.oracle

    l  注意:声明包的语句,必须写在程序有效代码的第一行(注释不算)

    package com.oracle; //包的声明,必须在有效代码的第一行
    
    import java.util.Scanner;
    import java.util.Random;
    
    public class Demo {}

          包的访问

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

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

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

    l  类的简化访问

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

    如:com.oracle包中有两个类,PersonTest类,与Person类。我们在PersonTest类中,访问Person类时,由于是同一个包下,访问时可以省略包名,即直接通过类名访问 Person。

    类名 变量名 = new 类名();
    Person p = new Person();

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

    package com.oracle02;
    public class Person {}

    1.1      import导包

    导包的格式:

    import 包名.类名;

         访问修饰符

     

    归纳一下:在日常开发过程中,编写的类、方法、成员变量的访问

    l  要想仅能在本类中访问使用private修饰;

    l  要想本包中的类都可以访问不加修饰符即可;

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

    l  要想所有包中的所有类都可以访问使用public修饰。

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

      代码块

     1.     局部代码块

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

    特点:

    l  以”{}”划定的代码区域,此时只需要关注作用域的不同即可

    l  方法和类都是以代码块的方式划定边界的

    class Demo{
        public static void main(String[] args)    {
            {
                      int x = 1;
                     System.out.println("普通代码块" + x);
            }
            int y = 99;
            System.out.println("代码块之外" + y);
        }
    }

    普通代码块1

    代码块之外99

    2.     构造代码块

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

    特点:

    l  优先于构造方法执行,构造代码块用于执行所有对象均需要的初始化动作

    l  每创建一个对象均会执行一次构造代码块。

     

    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);
        }
    }

    3.      静态代码块

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

    特点:

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

    l  该类不管创建多少对象,静态代码块只执行一次。

    l  可用于给静态变量赋值,用来给类进行初始化。

    public class Person {
        private String name;
        private int age;
         //静态代码块
        static{
            System.out.println("静态代码块执行了");
        }
    }
  • 相关阅读:
    Java实现 LeetCode 400 第N个数字
    Java实现 LeetCode 400 第N个数字
    Java实现 LeetCode 399 除法求值
    Java实现 LeetCode 399 除法求值
    Java实现 LeetCode 399 除法求值
    Java实现 LeetCode 398 随机数索引
    Java实现 LeetCode 398 随机数索引
    Java实现 LeetCode 398 随机数索引
    linux中的cd ..和cd -命令有什么区别?
    GCC使用
  • 原文地址:https://www.cnblogs.com/111wdh/p/13269282.html
Copyright © 2011-2022 走看看