类和对象（内部类）

最新推荐文章于 2022-04-23 17:50:01 发布
最新推荐文章于 2022-04-23 17:50:01 发布
阅读量237 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： 类  内部类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/sspudding/article/details/83512906

面向对象

面向对象的程序设计（简称OOP）有三个基本特征：封装、继承和多态。
用面向对象的语言和面向对象的思想。

类和对象

类的声明
[类的修饰符] class 类名[extends 基类][implements 接口列表]{
    类体
 }[;]
 //[]注明为可选
 //类名：一般采用PascalCase命名规范
对象的创建

类是抽象的，要使用类定义功能，必须实例化类，即创建类的对象。

Person person = new Person();
//或
Person person;
person = new Person();
对象的使用
变量 = 对象名.成员变量
person.age = 18;
对象名.方法（）;
person.print();
对象的初始化方式

提供一系列的get 和 set 方法

package com.tulun.src;
        class Person {
            private int age;
            private String name;
            private String sex;

            public int getAge() {
                return age;
            }

            public void setAge(int age) {
                this.age = age;
            }

            public String getName() {
                return name;
            }

            public void setName(String name) {
                this.name = name;
            }

            public String getSex() {
                return sex;
            }

            public void setSex(String sex) {
                this.sex = sex;
            }

            public void sleep() {//行为、方法 、函数
                System.out.println("Person.sleep()");
            }
            public void eat() {
                System.out.println("Person.eat()");
            }

            @Override //注解、重写
            public String toString() {
                return "Person{" +
                        "age=" + age +
                        ", name='" + name + '\'' +
                        ", sex='" + sex + '\'' +
                        '}';
            }
        }

        public class Demo5{
            public static void main(String[] args) {
                Person person = new Person();//实例化出来一个对象
                person.setAge(10);
                person.setName("zhangsan");
                System.out.println(person.getAge());
            }
        }

通过合适的构造函数进行初始化

  • 对象的创建分为两步：a.为对象分配内存 b.调用合适的构造函数
  • 构造方法用于执行类的实例的初始化工作
  • 构造方法的名称与类名相同
  • 构造方法不能声明返回类型（也不能使用void），也不能返回值
        class Person {
            private int age;//数据
            private String name;
            private String sex;
            //声明静态常量字段并赋初
            private static final int COUNT = 10;//位于方法区

            public Person() {//不带参数的构造函数，构造函数可以被重载
                this("李四","man",66);  //调用带有三个参数的构造函数
                System.out.println("Person()");
                this.age = 8; //this:指向当前对象的内存
                this.sex = "man";
                this.name = "王三";
            }
            public Person(String name,String sex,int age) { //带有三个参数的构造函数
                System.out.println("Person(name,sex,age)");
                this.age = age; //this:指向当前对象的内存
                this.sex = sex;
                this.name = name;
            }

            public Person(String name,String sex) { //带有两个参数的构造函数
                this.sex = sex;
                this.name = name;
            }
  • 方法的重载
    • 每个类型成员都有唯一的签名
    • 方法的签名由方法的名称及其参数的数目和类型组成
    • 方法的签名不包含返回类型
    • 只要方法的签名不同，就可以在一种类型内定义具有相同名称的多种方法，称作重载

静态初始化和实例初始化代

class Person {
    private int age; //实例字段
    private String name;
    private String sex;
    private  static  int count;//静态字段 

    {   //实例块初始化
        this.name = "ss";
        this.sex = "girl";
        this.age = 8;
        System.out.println("instance {} init");
    }

    public Person() { //构造方法
        System.out.println("Person().constrcutor");
    }
    //静态初始化
    static { //static所修饰的方法或者数据成员不依赖于对象
        count = 10;
        System.out.println("static {} init");
    }
    //静态方法
    public static void sleep() { 
        System.out.println("static.sleep()");
    }
    //实例方法
    public  void eat() { 
        System.out.println("static.eat()");
    }
  • 静态方法不对特定实例进行操作，只能直接访问静态成员
    • 在静态方法中使用this关键字会导致编译错误
    • 静态方法通过类来访问
  • 实例方法对某个给定的实例进行操作，能访问静态成员和实例成员
    • 在调用实例方法的实例上，可以通过this显示地访问该实例
    • 实例方法通过对象来访问

对象的初始化顺序：静态块初始化 (只初始化一次) —— 实例代码块初始化——构造函数初始化

class Person1{
    static{
        System.out.println("静态代码块初始化");
    }

    public Person1(){
        System.out.println("构造函数初始化");
    }

    {
        System.out.println("实例代码块初始化");
    }


}
public class Test1 {
    public static void main(String[] args) {
        Person1 a = new Person1();
    }
}

在这里插入图片描述

内部类

静态内部类
class OuterClass { //外部类
    public int data1; //公共实例字段
    private int data2; //私有实例字段
    private static int data3; //私有静态实例字段

    public OuterClass() {
        System.out.println("OuterClass() init");
    }

    public void test1() { //公共实例方法
        System.out.println("OuterClass().test1()");
    }
    //静态内部类
    static class InnerClass {
        public int data4;
        OuterClass outr; //用于保存外部类的实例
        public InnerClass(OuterClass outr) { //构造方法
            this.outr = outr;
            System.out.println("InnerClass()init");
        }
        public void test2() {
            System.out.println(data4);
            System.out.println(data3);
            System.out.println(outr.data1);
            System.out.println("InnerClass().test2()");
        }
    }
}
public class Demo5 {
    public static void main(String[] args) {
        //创建外部类的对象实例
        OuterClass outerClass = new OuterClass();
        //创建内部类的对象实例
        OuterClass.InnerClass innerClass1 = new OuterClass.InnerClass(outerClass);
        innerClass1.test2();
    }
}

静态内部类可以直接访问外部类的静态成员,如果访问外部类的实例成员,必须通过外部类的实例去访问。
可以通过类名直接访问静态内部类的静态成员

实例内部类

实例内部类的成员方法可以访问其外部类的所有成员

class OuterClass2 {
    public int data1;
    private int data2;
    private static int data3;

    {
        data1 = 999;
        data2 = 888;
        data3 = 777;
    }

    public OuterClass2() {
        System.out.println("OuterClass() init");
    }

    public void test1() {
        System.out.println("OuterClass().test1()");
    }

    class InnerClass2 {
        private int data3 = 100;
        public int data5 = 10;
        //private static  int date4 = 1000; error
        private static final int DATA4 = 1000;
        //实例内部类当中可以有静态数据成员但是只能是在编译期间确定的值即被final所修饰
        //private static final int DATA4 = data5; error

        public InnerClass2() {
            System.out.println("InnerClass2().init");
        }

        public void test2() {
            System.out.println(data1);//999
            System.out.println(data2);//888    OuterClass2.this.
            System.out.println(this.data3);//100
            System.out.println(OuterClass2.data3);//777
            //System.out.println(OuterClass2.this.data3); 警告
            System.out.println("InnerClass2().test2()");
        }
    }
    public static void main(String[] args) {
        // InnerClass2 innerClass2 = new InnerClass2(); error
        OuterClass2 outerClass2 = new OuterClass2();
        //外部类名.内部类名  对象 =  外部类对象.new 内部类();
        OuterClass2.InnerClass2 innerClass2 = outerClass2.new InnerClass2();
        innerClass2.test2();
    }
}
  • 实例内部类是否拥有外部类对象？
    • 拥有 ，因为有外部类的this引用对象。
  • 实例内部类当中是否可以有静态数据成员？
    • 可以有。但是只能是在编译期间确定的值即被final所修饰。
匿名内部类

匿名内部类没有显示的类名，在声明的同时，必须使用new关键字创建其对象实例。
匿名内部类一般用于比较简单，且仅在声明处使用一次的类

class OuterClass {
    public void sayHello() {
        System.out.println("hello");
    }
}
public class Demo5 {
    public static void test(OuterClass out1) {
        out1.sayHello();
    }
    public static void main(String[] args) {
        //第一种
        new OuterClass() {
            public void sayHello() {
                System.out.println("main : hello");
            }
        }.sayHello();
       //第二种
        test(new OuterClass());
    }
}

匿名内部类能不能访问方法的局部变量

    public static void main(String[] args) {
        int a = 10;
        new Object(){
            public void fun(){
                int b = a;
            }
        };
    }
//无输出

进栈 出栈

class Stack {
    private int top;//栈顶指针
    private int[] elem;
    private int usedSize;

    /*public Stack() {
        this.top = 0;
        this.elem = new int[10];
    }*/
    public Stack() {
        this(10);
    }
    public Stack(int size) {
        this.elem = new int[size];
    }
    //行为==》方法
    public boolean isFull() {
        if(this.top == this.elem.length) {
            return true;
        }
        return false;
    }
    //进栈
    public void push(int val) {
        if(isFull()) { //判断栈是否满
            return;
        }
        this.elem[top++] = val;//进栈——栈顶指针加一
        this.usedSize++;
    }

    public boolean isEmpty() { //判断栈是否为空
        return this.top == 0;
    }

    public void pop() { //出栈
        if(isEmpty()) {
            return;
        }
        this.top--; //出栈——栈顶指针减一
        this.usedSize--;
    }

    public void show() {
        for (int i = 0; i < this.top; i++) {
            System.out.print(this.elem[i]+" ");
        }
        System.out.println(this.usedSize);
    }
}

public class Demo5 {
    public static void main(String[] args) {
        Stack stack = new Stack();
        stack.push(10);
        stack.push(20);
        stack.push(30);
        stack.show();
        stack.pop();
        stack.show();
    }
 }
sspudding
关注
面向对象之内部类
qq_51993933的博客
03-05 198
内部类 1.为什么使用内部类? 使用内部类就是在前一个类的内部再定义一个类。比如，A类中定义了一个B类，则B类相对于A类来说称为内部类，A类相对于B类来说就是一个外部类。 使用内部类的好处在于每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。 1.1.使用内部类最大的优点就在于它能够非常好的解决多重继承的问题,使用内部类还能够为我们带来如下特性: 1.内部类可以用多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独。 2.
对Java的面对对象编程中对象和引用以及内部类的理解
09-02
- 内部类是在另一个类的内部定义的类，可以分为：成员内部类（包括静态内部类）、局部内部类和匿名内部类。 - 成员内部类可以直接访问外部类的所有成员，包括私有成员，但需要先创建外部类对象才能创建内部类对象...
类/对象/内部类
weixin_45435381的博客
12-19 361
一 注意事项总结 1.1 构造方法 构造方法是没有返回值的；构造方法的名称要与本类的名称相同。 如果再类中定义的构造方法都不是无参的构造方法，则编译器不会为类设置一个默认的午餐构造方法，当试图调用无参构造方法实例化一个对象时，编译器会报错，所以只用在类中没有定义任何构造方法时，编译器才会在该类中自动创建一个不带参数的构造方法。 public class AnyThting { public AnyThting() { this("this调用有参构造方法"); } public AnyThti
面向对象中的内部类
weixin_44603047的博客
01-31 149
面向对象中的内部类JAVA中的内部类成员内部类：静态内部类局部内部类匿名内部类内部类总结： JAVA中的内部类 Java的四种内部类包括如下： 成员内部类 静态内部类 局部内部类 匿名内部类 成员内部类： 定义在另一个类(外部类)的内部，而且与成员方法和属性平级叫成员内部类，…相当于外部类的非静态方法，如果被static修饰，就变成静态内部类了。 1．内部类作为外部类的成员，可以访问外部类的...
类与对象
sxjiao96的博客
09-19 189
类与对象
java内部类，与对象的理解
qq_41648092的博客
01-18 148
package equality; public class Parcel1 { class Contents{ private int i=11; public int value(){return i;} } class Destination{ private String label; Destination(String whereTo){ label=wh...
JAVA常用类与内部类
12-22
1、成员内部类：定义在类中的类，属于类的成员，创建成员内部类对象必须依赖外部类对象。 2、静态内部类：定义在类中的类，class 关键字前加入 static 修饰符，创建静态内部类对象不需要外部类对象。 3、局部内部...
Java开发之内部类对象的创建及hook机制分析
08-28
一、内部类的定义和特点 在Java中，内部类是一种特殊的类，它是定义在另一个类内部的类。内部类可以访问外围类的所有成员，包括私有成员，而外围类也可以访问内部类的所有成员。内部类的定义方式是在外围类的内部...
匿名内部类
12-22
所谓匿名内部类（anonymous inner class），是指可以利用内部类创建没有名称的对象，它一步完成了声明内部类和创建该类的一个对象，并利用该对象访问到类内的成员，这种类不取名字，而是直接用其父类的名字或者它所...
面向对象类继承和内部类精选.pptx
10-09
面向对象类继承和内部类精选.pptx
内部类对象
weixin_43871309的博客
08-24 140
内部类对象 成员内部类 实例化内部类需要声明外部类 若想访问外部类属性 out.this.name 可以包含静态常量，不能包含静态成员 静态内部类 相当于一个外部类，级别和外部类相同 只有内部类，才可以用static修饰。 局部内部类 不能加任何修饰符。 匿名内部类 通过匿名内部类实例化一个借口 ...
面向对象_内部类
java_zjs的博客
04-02 341
package Interface; /** * 内部类：把一个类定义在另一个类的内部称为内部类 * 使用：创建内部类的对象的时候，需要在内部类的前面加外部类来进行修饰 * 1.内部类可以直接访问外部类的属性和方法 * 2.外部类要想访问内部类，则需创建内部类的对象才可访问 * 3.内部类中不能定义静态属性(静态当然可以) * 4.当内部类和外部类有相同的（属性或者方法）的时候，在内部类中可以直接访问内部类的（属性或方法） * 如果想访问外部.
Java面向对象之内部类
qq15035899256的博客
01-28 1104
Java面向对象之内部类的学习，了解成员内部类、局部内部类、匿名内部类、静态内部类的用法。重点掌握成员内部类和静态内部类。
局部内部类
阿劼
04-23 279
本地内部类，又叫局部内部类，是定义在方法内部的类，只在定义其的代码块中是可见的。 如果想调用局部内部类的方法，必须在方法中实例化这个类。 看以下例子： class TestDemo{ private int a = 20; private int b = 30; public void test(){ int data1 = 10; ...
面向对象-内部类
m0_64185725的博客
04-23 359
将一个类定义置入另一个类定义中就叫作“内部类” 类中定义的内部类特点： 1.内部类作为外部类的成员，可以直接访问外部类的成员（包括private成员），反之则不行。 2.内部类做为外部类成员，可声明为private、默认、protected戒public。 3.内部类成员只有在内部类的范围之内是有效的。 4.用内部类定义在外部类中不可访问的属性。这样就在外部类中实现了比外部类的private还要小的访问权限。 内部类分类: 成员内部类 静态内部类 方法内部类 匿名内部类 成员内部类..
内部类
凄戚的博客
04-02 229
内部类内部类最简单的内部类（由易到难）简单内部类链接到外部类使用.this与.new插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 内部类 内部类：可以将一个类的定义放在另一个类的定义内部。 内部类是一种非常有用的特性，它允许你把一些逻辑相关的类组织在一起，并控制内部的类的可视性。内部类与
Java类和对象(内部类)
m0_60631323的博客
04-15 575
一、内部类的概念二、 实例内部类三、静态内部类四、局部内部类五、匿名内部类 一、内部类的概念 当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类。在 Java 中，可以将一个类定义在另一个类或者一个方法的内部， 前者称为内部类，后者称为外部类。内部类也是封装的一种体现。 public class OutClass { class InnerClass{ } } // OutClass是外部类 // InnerCl.
java对象--内部类
weixin_33859665的博客
04-21 100
2019独角兽企业重金招聘Python工程师标准>>> ...
C++类和对象习题精讲与答案解析
C++中的类和对象是面向对象编程（OOP）的核心概念。 在C++中，类是一种用户自定义的数据类型，它允许封装数据成员（也称为属性）和函数成员（也称为方法）。类定义了一个模板，可以用来创建对象。对象是类的实例，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值