this关键字+内部类

最新推荐文章于 2024-09-25 21:16:15 发布
最新推荐文章于 2024-09-25 21:16:15 发布
阅读量680 收藏 6
点赞数
分类专栏： Java 文章标签： java 内部类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_47173597/article/details/119460214
版权

目录

一：this关键字

               1：调用本类属性

               2：调用本类方法

               3：表示当前对象

二：内部类

               外部类访问内部类私有属性

              使用static定义内部类。

              最常用：在方法中定义内部类。 

一：this关键字

1：调用本类属性

class Book{
	private String title;
	private double price;
	public Book(String title,double price) {
		this.title=title;
		this.price=price;
	}
	public String getInfo() {
		return "书名："+title+";"+"价钱："+price;
	}
}

public class STATIC {
     public static void main(String[] args) {
       Book A=new Book("JAVA",99);
       System.out.println(A.getInfo());
     } 	
	}

 注意：如果不加this，Java会就近选择变量，也就是函数的参量。如果变量前用this限定，那么便会找类中的属性。
结论：为了避免错误，只要访问类中的属性那么：在属性前加上：this关键字

 2：调用本类方法

1）：调用普通方法

class Book{
	private String title;
	private double price;
	public Book(String title,double price) {
		this.title=title;
		this.price=price;
	}
	public void print() {
		System.out.println("/*图书信息：*/");
	}
	public String getInfo() {
		this.print();
		return "书名："+title+";"+"价钱："+price;
	}
}

public class STATIC {
     public static void main(String[] args) {
       Book A=new Book("JAVA",99);
       System.out.println(A.getInfo());
     } 	
	}

注意：类内调用类的普通方法，可以直接调用，但为了严谨，最好加上this。

2）：调用构造方法(可用于简化重复代码)

之前：

    class Book{
	private String title;
	private double price;
	public Book() {
		
	}
	public Book(String title) {
		this.title=title;
	}
	public Book(String title,double price) {
		this.title=title;
		this.price=price;
	}
	
	public String getInfo() {
		return "书名："+title+";"+"价钱："+price;
	}
}

public class STATIC {
     public static void main(String[] args) {
       Book A=new Book();
       System.out.println(A.getInfo());
       Book B=new Book("JAVA");
       System.out.println(B.getInfo());
       Book C=new Book("JAVAc",99);
       System.out.println(C.getInfo());
     } 	
	}

改变后：

class Book{
	private String title;
	private double price;
	public Book() {
		System.out.println("图书信息：");
	}
	public Book(String title) {
		this();//调用无参的构造函数
		this.title=title;
	}
	public Book(String title,double price) {
		this(title);//调用有一个参数的构造函数
		this.price=price;
	}
	
	public String getInfo() {
		return "书名："+title+";"+"价钱："+price;
	}
}

public class STATIC {
     public static void main(String[] args) {
       Book A=new Book();
       System.out.println(A.getInfo());
       Book B=new Book("JAVA");
       System.out.println(B.getInfo());
       Book C=new Book("JAVAc",99);
       System.out.println(C.getInfo());
     } 	
	}

注意：this（）或this（参数）必须放在第一行。而且不可以递归调用，比如无参构造方法调用了第二个构造方法。所以必须有一个构造方法不要：this。

class Emp{
   private int empno;//编号
   private String ename;//姓名
   private double sal;//工资
   private String dept;//部门
   
   public Emp(int empno,String ename,double sal,String dept) {
	   this.empno=empno;
	   this.ename=ename;
	   this.sal=sal;
	   this.dept=dept;
   }
   public Emp(String ename,double sal) {
	   this(0,ename,sal,"暂无");
   }
   public String getInfo() {
	   return empno+";"+ename+";"+sal+";"+dept;
   }
}

public class STATIC {
     public static void main(String[] args) {
       Emp a=new Emp("张丽",10000);
       System.out.println(a.getInfo());
     } 	
	}

 结果：0;张丽;10000.0;暂无   利用四参构造函数定义二参。

3：表示当前对象

 当前对象：当前正在调用类中方法的实例化对象。

 

 对象之间的传递：

class A{
	private B b;
	public A() {//2：执行A类构造
		//3：为B类对象b实例化
		this.b=new B(this);/*4:this表示当前对象，就是tmp*/
		this.b.get();//7:调用B类中的get()方法
	}
	public void print() {
		//10:调用print（）输出
		System.out.println("hello,world!");
	}
}
class B{
	private A a;
	//5:把tmp对象传到参数a a=tmp;
	public B(A a) {
		this.a=a;//6:保存a对象，即tmp
	}
	//8:调用此方法
  public void get() {
	  this.a.print();//9：this.a就是传过来的tmp.
  }
  }

public class STATIC {
     public static void main(String[] args) {
      A tmp=new A();//1:实例化对象，调用无参构造方法
     } 	
	}

输出：hello world! 
通过new B(this)把主过程定义的对象赋值给B中对象a,然后对象a再被赋值给A类对象b.
也就是：tmp=B类中的this.a=A类中的this.b;

 总结：this用法
1：类中的属性调用以后都要加上this；
2：类中的构造方法的相互调用。
3：this1表示的当前的对象，不是固定的对象。

二：内部类

所谓内部类就是：在一个类的内部继续定义其他内部结构类的情况

class Outer{//外部类
	private String meg="hello,world!";
	class Inner{//定义一个内部类
		public void print() {
			System.out.println(meg);
		}
		}//内部类终止
	/*实例化内部对象并调用方法print()*/
	public void fun() {
		new Inner().print();
	}
}
public class STATIC {
     public static void main(String[] args) {
    	Outer out=new Outer();
    	out.fun();
     } 	
	}

通过实例化外部类调用外部类的方法，方法内部通过实例化内部类调用内部类的方法。

内部类破坏了类的结构只有属性和方法的结构，但是也会带来方便访问外部类的私有属性的好处。

把Inner类放在外部，同样实现此功能。 
核心：如何让Inner类可以访问到Outer类的私有属性meg.

class Outer{
	private String meg="hello,world!";
	public void fun() {
		new Inner(this).print();
	}
	public String getMeg() {
		return this.meg;
	}
}

class Inner{
	//为了实现一个对象的访问，必须通过应用，所以把主方法的out对象传递给内部类的o.
	private Outer o;
	public Inner(Outer out) {
		this.o=out;
	}
	
	public void print() {
		System.out.println(this.o.getMeg());
	}
	}

public class STATIC {
     public static void main(String[] args) {
    	Outer out=new Outer();
    	out.fun();
     } 	
	}

外部类访问内部类私有属性

class Outer{
	   private String msg="外部类私有属性";
        class Inner{
        	private String info="内部类私有属性";
        	public void print() {
        		System.out.println(msg);
        	}		
        }
        /*实例化内部类对象来访问内部类私有属性。*/
        public void fun() {
        	Inner in=new Inner();
        	System.out.println(in.info);
        }
}

public class STATIC {
     public static void main(String[] args) {
             Outer out=new Outer();
             out.fun();
     } 	
	}

本代码如果：如果内部类访问外部类属性，不能直接加this,而应该外部类.this.属性。即：Outer.this.msg

主程序直接实例化内部类对象。

class Outer{
	   private String msg="外部类私有属性";
        class Inner{
        	private String info="内部类私有属性";
        	public void print() {
        		System.out.println(Outer.this.msg);//msg
        	}		
        }
       
}

public class STATIC {
     public static void main(String[] args) {
            Outer.Inner in=new Outer().new Inner();
            in.print();
     } 	
	}

语法：外部类 内部类  对象名=new 外部类().new 内部类();

使用static定义内部类。

       由于static定义的属性和方法不受类的实例化对象控制，所以内部类被static定义，那么这个类变成了外部类，而且只能访问外部类的static属性和static方法。

class Outer{
	    private static String msg="Outer类属性";
	    static class Inner{
		      public void print() {
			   System.out.println(msg);
		         }
	     }
}

public class STATIC {
     public static void main(String[] args) {
          Outer.Inner in=new Outer.Inner();
          in.print();
     } 	
	}

注意：
1：Inner被static修饰，相当于外部类，所以必须把私有属性变为static才可以被访问。
2：在实例化内部类对象时;外部类。内部类视为一个整体。

最常用：在方法中定义内部类。 

class Outer{
	    private String msg="Outer类属性";
		public void fun() {
			//在fun方法中定义了内部类Inner
		    class Inner{
		    	public void print() {
		    		System.out.println(Outer.this.msg);
		    		  }
		    	  }
		    //fun方法实例化Inner对象调用print()方法
			   new Inner().print();
		         }
	     }


public class STATIC {
     public static void main(String[] args) {
         new Outer().fun();
     } 	
	}

class Outer{
	    private String msg="Outer类属性";
		public void fun(int num) {//num:方法的参数
			double score=100;//方法的属性
		    class Inner{
		    	public void print() {
		    		//内部类从jdk1.8之后可以直接访问：方法的参数和变量
		    		System.out.println(msg+";"+num+";"+score);
		    		  }
		    	  }
			   new Inner().print();
		         }
	     }


public class STATIC {
     public static void main(String[] args) {
         new Outer().fun(100);
     } 	
	}

代码运行结果：Outer类属性;100;100.0

 总结：内部类与外部类可以方便的访问各自的私有属性。内部类被private后不可以在主程序通过外部类.内部类去实例化。

【Java】还不懂this关键字？一分钟彻底弄懂this关键字
Yaoyao2024的博客
01-26 5万+
在上一篇【JavaSE】一文看懂构造器/构造方法（Cunstructor）中，我们已经在构造器中初步窥得this关键字的冰山一角了。大家有没有考虑过，在一个类的构造器中，我们为什么要使用this.属性而不直接使用属性呢？毕竟一个类中，不管属性被什么关键字修饰，在类中都可以访问。随着这个问题，今天瑶瑶子带大家深入分析一下Java中this关键字,让大家彻底理解this关键字.
Java中的this关键字
m0_56426418的博客
08-09 572
thisthis关键字可以用于引用当前类的实例变量（成员变量）或方法，以区分成员变量和局部变量（如果它们有相同的名字）。：在一个构造方法内部，this可以用来调用同一个类的另一个构造方法。但需要注意的是，这种调用必须是构造方法的第一条语句。：在某些情况下，this可以用于返回当前对象的引用。
java 内部类中的this_java中的内部类
weixin_35782626的博客
02-20 1117
一、内部类及访问特点1:内部类概述:把类定义在其他类的内部，这个类就被称为内部类。理解：内部类不需要被其他外部类调用，所以内部类定义在外部类里边，连成一块。2:内部类访问特点：a:内部类可以直接访问外部类的成员，包括私有。b:外部类要访问内部类的成员，必须创建对象。二、分类分类： 成员位置:在成员位置定义的类，被称为成员内部类(不在方法里)，又分为静态和非静态局部位置:在局部位置定义的类，...
内部类的this
atarik@163.com
06-30 533
内部类的this有三种指向： 1、本类的成员，即this.getDataHandle 2、父类的成员，即super.getDataHandle 3、所属类的成员，即MainSystem.this.getDataHandle
java中的this关键字/内部类
m0_37327931的博客
07-14 589
一、this关键字代表当前对象         this.属性  操作当前对象的属性        this.方法   调用当前对象的方法 二、封装对象的属性的时候，经常会使用this关键字。 三、内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。 内部类作用： 1. 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许
Java修炼——内部类详解
欢迎来到我的博客，一起学习Java！
07-15 290
内部类详解 定义：将一个类定义在另一个类的内部，该类就称为内部类 类中定义的内部类特点： 内部类作为外部类的成员，可以直接访问外部类的成员 （包括 private 成员），反之则不行。 内部类做为外部类成员，可声明为 private、默认、 protected或 public。 内部类成员只有在内部类的范围之内是有效的。 用内部类定义在外部类中不可访问的属性。这样就在外部 类中实现了比外部类的 ...
Java内部类的this问题
imxiangzi的专栏
09-06 8455
一轮红日映朝阳 首页  标签  搜索  留言 Java内部类的this问题 2011-9-15 16:23:45 在一个风和日丽的下午，码农A写了一个可以获取数据的组件，代码是这样的： package net.gerhut.example.authora; public class Component {
3.5 Java this关键字全解（this关键字调用本类属性、成员、构造方法）
最新发布
Argonaut_的博客
09-25 1951
引用当前对象：在非静态方法中，this关键字可以用来引用当前对象，即调用方法的实例。这在需要引用当前对象的成员变量或方法时非常有用，尤其是当成员变量与方法参数同名时。关键字调用成员方法可以使得代码更加清晰和易于理解，尤其是在需要递归调用或者在方法内部调用另一个重载版本的方法时。关键字不仅可以用于引用当前对象的属性，还可以用于调用当前对象的成员方法。调用当前类的其他构造方法：在构造方法中，this关键字可以用来调用当前类的其他构造方法，这有助于减少代码重复并提高代码的可维护性。这被称为构造方法的链式调用。
关于javascript中this关键字(翻译+自我理解)
10-28
首先，让我们了解JavaScript中的this关键字。在JavaScript中，this的指向不像其他一些面向对象的编程语言中那样固定，而是依赖于函数的调用方式。在传统的面向对象语言中，this关键字通常指代当前对象，但在...
Java面向对象高级教程：this与static关键字，内部类解析
"面向对象(高级)的Java学习笔记，包括this关键字、static关键字以及内部类的讲解，并结合链表程序示例深入理解引用传递和this的使用。" 面向对象编程是Java的核心特性，本笔记主要涵盖了面向对象的高级概念，包括...
关于在内部类中类名.this的使用
DiligentDog的博客
11-15 1697
在看ArrayList的源码的时候，ArrayList中有一个实现了Iterator接口的内部类Itr，在内部类里，有两个elementData变量，一个是内部类的，昨天的是内部类的局部变量，右边的 是ArrayList的全局变量，由于ArrayList的全局变量elementData与内部类中的elementData重名，所以内部类引用外部类的同名变量时，需要在外部类的全局变量前加上 类名.
类名.this：内部类引用外部类实例
摸魚散人的博客
01-07 1504
1. 深入解析类名.this：内部类引用外部类实例的奥秘 2. 内部类访问外部类实例：Java编程的独特之处 3. 为什么内部类能够访问外部类实例？机制揭秘 4. 内部类修改外部类实例：编程的灵活性 5. 成员内部类与外部类的关系：详解访问与修改实例的方法 6. Fail-Fast vs. Fail-Safe：集合迭代机制的实现原理研究
内部类与this
qiaoqinqie的专栏
08-08 1543
java内部类的this和new语法
wzx19840423的专栏
01-12 1295
内部类中.this使用
乱七八糟
01-09 529
  private class Itr implements Iterator<E> { public void remove() { if (lastRet == -1) throw new IllegalStateException(); checkForComodification(); try { A...
Java基础(六)：this关键字
mingyuli的博客
06-14 322
1、为什么要引入this关键字？ 2、 3、 参考：https://zhuanlan.zhihu.com/p/70414228
Java 中的成员内部类（转载）
weixin_34235105的博客
06-25 208
内部类中最常见的就是成员内部类，也称为普通内部类。我们来看如下代码：运行结果为：从上面的代码中我们可以看到，成员内部类的使用方法：1、Inner 类定义在 Outer 类的内部，相当于 Outer 类的一个成员变量的位置，Inner 类可以使用任意访问控制符，如 public 、 protected 、 private 等2、Inner 类中定义的 test() 方法可以...
【转载保存】匿名内部类中this的使用
dreamzuora的博客
04-14 893
转载链接：https://www.cnblogs.com/yaowen/p/9471389.html 代码使用模板使用： package test; public class A extends B { public String toString() { return "A"; } public static void main(Str...
内部类之.this和.new
及时雨的csdn
04-23 387
如果你需要生成对外部类对象的引用,可以使用外部类的名字后面紧跟着圆点和this.这样产生的引用自动地具有正确的类型,这一点在编译期间就被知晓并受到检查,因此没有任何运行时期的开销. 有时你可能想告知某些其他对象,去创建某个内部类的对象,要实现此目的,你必须在new表达式中提供对其他外部类对象的引用,这需要圆点和new语法. 创建内部类的两种方法: 1.在外部类中创建一个方法,该方...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值