this表示当前对象


在一个类之中肯定会产生诺干个对象，那么程序类在分辨的时候不会记住具体有多少个对象产生了，它唯一可能知道的当前操作本类的对象是哪一个。
范例：观察当前对象 


class Person{
public  void fun() {
	System.out.println("【fun方法】"+this);
	}}

public class StringDemo {
public static void main(String args[]) {
Person p1=new Person();
System.out.println("【Main方法】"+p1);
p1.fun();//由p1这个对象调用了fun()方法(this=p1)
System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
Person p2=new Person();
p2.fun();
}
}	

//结果
【Main方法】Person@10dea4e
【fun方法】Person@10dea4e
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

【fun方法】Person@647e05
在整体的操作过程之中，this定义没有变，
只要有某一个对象调用了本类中的方法，那么这个this就表示当前执行的对象。

1.this关键字
     this表示当前对象的引用。——可以借助this来访问对象的方法和字段。
 
2.代码：
 
class Person{
    private String name;//实例成员变量
    private int age;
    private String sex;

    //默认构造函数    构造对象
    public Person(){
        //this调用构造函数
        this("zhangsan",22,"man");//必须放在第一行进行显示
    }
    //这两个构造函数之间的关系为重载。
    public Person(String name,int age,String sex){
        this.name = name;//this 代表当前对象的引用
        this.age = age;
        this.sex = sex;
    }

    public void show(){
        System.out.println("name:" + name + " age:" + age + " sex:" + sex);
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person = new Person();//调用不带参数的构造函数
        person.show();

    }
}
 
3.运行结果：
 
 
4.分析：
 
可发现在构造函数的内部，我们可以使用this关键字，构造函数是用来创建对象的，对象还没有构造好，我们就使用了this，那么此时this怎么会代表当前对象呢？
 
因此this代表的是当前对象的引用。

目录
 
1、调用本类属性
 
2、调用本类方法
 
3、表示当前对象
 

this是一个非常灵活的关键字，不会明确表示一个固定概念，比如int，它就是表示一个整型。
 
1、调用本类属性
 
类中有许多成员，大部分情况下类中直接进行成员调用，但是为了清楚的描述调用是本类属性，会用this.属性表示。
 
    class Person{
        String name;
        int age;
        public Person(){}
        public Person(String name, int age) {
            name = name;
            age = age;
        }
    }
 
如上定义的类，构造方法按上述写法，对象中不会保存我们定义的内容，而是默认值，因为程序以{}为界定范围，如果在此范围内有指定的变量名称，则会直接调用，若没有，则会调用类中的相应属性。
 
当参数与属性名称相同时，则会出现混淆，则需要用户自己手动明确调用的是属性还是方法中的参数，若是属性，则需要加this.属性，标准程序开发中都会以此方式进行：
 
    class Person{
        String name;
        int age;
        public Person(){}
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
    }
 
2、调用本类方法
 
一个类中存在普通方法和构造方法，this调用本类方法时，对应的语法不同：
 
1）调用本类中的其他方法：this.方法()
 
一个类中可能存在很多方法，这些方法之间可以直接进行调用，但是不够标准，应用this.方法()调用，标准化风格。
 
2）调用本类其他构造方法：this()
 
一个类中可以有多个方法，且可以重载，并且构造方法在实例化对象时只能被调用一次。
 
若现在需求：Person类中中有三个构造方法，无论调用哪个构造方法，都要求执行语句"**********"。
 
【举例】：原始实现方式
 
    class Person{
        String name;
        int age;
        public Person(){
            System.out.println("********");
        }
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
            System.out.println("********");
        }
    }
 
程序设计的一个重要原则，避免重复代码。按照这个原则，以上的代码并不符合开发要求，这时可以使用this()形式实现，调用本类无参构造。
 
class Person{
        String name;
        int age;
        public Person(){
            System.out.println("********");
        }
        public Person(String name) {
            this();
            this.name = name;
        }
        public Person(String name, int age) {
            this(name);
            this.name = name;
            this.age = age;
        }
    }
 
需要注意的是，this()形式只能放在构造方法的首行。在使用this()调用本类其他构造方法时，应该避免循环调用。
 
下面通过实例说明构造方法互调的意义所在。
 
【举例】：写一个雇员的信息类，类中提供如下四个属性：姓名、职位、部门、工资，还有4个构造方法：
 
无参构造：姓名未知、职位待定、部门后勤、工资为0；
单参构造（姓名）：职位主管、部门技术部、工资10；
双参构造（姓名、部门）：职位工程师、工资5；
四参构造。
针对以上要求可以有两种代码实现方法：
 
第一种：传统实现
 
protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Emp emp = new Emp();
        System.out.println(emp.getInfo());

    }


    class Emp{
        private String name;
        private String job;
        private String dept;
        private double sal;

        public Emp(){
            this.name ="未知";
            this.job = "待定";
            this.dept = "后勤";
            this.sal = 0.0;
        }
        public Emp(String name){
            this.name =name;
            this.job = "主管";
            this.dept = "技术部";
            this.sal = 10.0;
        }
        public Emp(String name,String dept){
            this.name =name;
            this.job = "工程师";
            this.dept = dept;
            this.sal = 5.0;
        }

        public Emp(String name,String job, String dept, double sal){
            this.name =name;
            this.job =job;
            this.dept = dept;
            this.sal = sal;


        }
        public String getInfo(){
            return "姓名："+this.name+"职位："+this.job+"部门："+this.dept+"工资："+this.sal;
        }
    }
 
以上程序重复的代码太多，过于冗余。
 
第二种：使用this改进
 
 protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Emp emp = new Emp();
        System.out.println(emp.getInfo());

    }


    class Emp{
        private String name;
        private String job;
        private String dept;
        private double sal;

        public Emp(){
            this("未知","待定","后勤",0.0);
        }
        public Emp(String name){
            this(name,"主管","技术部",10.0);
        }
        public Emp(String name,String dept){
            this(name,"工程师",dept,5.0);
        }

        public Emp(String name,String job, String dept, double sal){
            this.name =name;
            this.job =job;
            this.dept = dept;
            this.sal = sal;
        }
        public String getInfo(){
            return "姓名："+this.name+"职位："+this.job+"部门："+this.dept+"工资："+this.sal;
        }
    }
 
以上代码消除了很多重复代码，实际开发中应用较多。
 
3、表示当前对象
 
一个类，可以生成若干个对象，每个对象都可调用类中的方法，类中实际上很难描述某一个具体的对象，为了能区分出当前正在操作类中的方法是哪一个，可以使用this完成。
 
【举例】：观察
 
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Person perA = new Person();
        Person perB = new Person();

        System.out.println("MainActivity类中对象输出："+perA);
        System.out.println("MainActivity类中对象输出："+perB);

    }

    class Person{
    }
 
 
protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Person perA = new Person();
        Person perB = new Person();

        System.out.println("MainActivity类中对象输出："+perA);
        perA.print();
        System.out.println("--------------------------------");
        System.out.println("MainActivity类中对象输出："+perB);
        perB.print();

    }

    class Person{

        void print(){
            System.out.println("Person类中的输出，this="+this);
        }
    }
 
 
由以上可知，由perA调用print()方法时，this=perA,由perB调用print()方法时，this=perB, 所以，this的对象引用会随着调用类方法对象的不同而不同，属于相对性的概念。
 
进一步考虑，this.属性表示的就是当前对象中的属性。
 
 
 
作于202004051735，已归档
 
———————————————————————————————————
 
本文为博主原创文章，转载请注明出处！
 
若本文对您有帮助，轻抬您发财的小手，关注/评论/点赞/收藏，就是对我最大的支持！
 
祝君升职加薪，鹏程万里！

类与对象（Java）
 
一、什么是面向对象？：是现在最为流行的软件设计与开发方法
 
 
 
1.它是一种模块化的设计模式
 2.特点：封装性、继承性和多态性
 3.那么什么是？
 封装性：规定了不同级别的可见性的访问权限
 继承性：派生类（子类）继承了超类（父类）的所有内容，并相应的增加了一些自己新的成员
 多态性：允许程序中出现重名现象 如----方法重载/对象多态
 
 
二、什么是类？：类是由成员属性和方法组成的
 
 
 
1.实际上成员属性就是变量，方法就是一些操作行为（在C里面方法叫做函数）
 
 
class Person{           //定义一个类
	String name;       //【成员属性】人的姓名
	int age;		   //【成员属性】人的年龄
	public String getname(){	//获取name的属性内容
		return name;
	}
	public int getage(){	//获取age的属性内容
		return age;
	}
	public void tell(){
		System.out.println("姓名: " + name + "年龄： " + age); //输出
	}
}
 
三、什么是对象？：对象表示的是一个个独立的个体，对象的所有功能必须由类定义
 
 
 
1.对象需要通过关键字new来分配内存空间才能使用
 2.通过实例化对象可以进行类操作
 
 
class Person{           //定义一个类
	String name;       //【成员属性】人的姓名
	int age;		   //【成员属性】人的年龄
	public String getname(){	//获取name的属性内容
		return name;
	}
	public int getage(){	//获取age的属性内容
		return age;
	}
	public void tell(){ //输出函数
		System.out.println("姓名: " + name + "年龄： " + age); 
	}
}

public class JavaDemo{	//通过实例化对象进行类操作
	public static void main(String args[]){
		Person per = new Person();	//声明并实例化对象，其实也就是说给对象per分配了一块堆内存的空间来保存该类中的成员属性
		per.name = "张三";
		per.age = 18;
		per.tell();
	}
}
 
四、对象内存是怎样分配的？：对象名称----栈内存、具体信息—堆内存
 
五、引用传递？：每一块栈内存都会保存有堆内存的信息，并且只允许保存一个堆内存的地址信息
 
 
 
这里有一点继承的意思在里面，通过引用传递，可以使新的对象保存旧的对象里面堆内存的信息，同时旧的对象也可以使用堆内存信息
 
 
public class JavaDemo{	//通过实例化对象进行类操作
	public static void main(String args[]){
		Person per1 = new Person();	//声明并实例化对象，其实也就是说给对象per分配了一块堆内存的空间来保存该类中的成员属性
		per1.name = "张三";
		per1.age = 18;
		Person per2 = per1;	//引用传递（有一点C里面赋值的意思在里面）
		per2.age = 80;
		per1.tell();	//通过引用传递可以改变堆内存中保存的信息，这时再输出对象per1的年龄则变为80了
	}
}
 
六、什么是成员属性封装？：只能通过方法来改变，封装内的属性/或实例化对象
 
class Person{           //定义一个类
	private String name;       //【成员属性】人的姓名
	private int age;		   //【成员属性】人的年龄
	public void setname(String tempname){	//设置name的属性
		name = tempname;
	}
	public void setage(int tempage){	//设置age的属性
		age = tempage;
	}
	public String getname(){	//获取name的属性内容
		return name;
	}
	public int getage(){	//获取age的属性内容
		return age;
	}
	public void tell(){ //输出函数
		System.out.println("姓名: " + name + "年龄： " + age); 
	}
}

public class JavaDemo{	//通过实例化对象进行类操作
	public static void main(String args[]){
		Person per = new Person();	//声明并实例化对象，其实也就是说给对象per分配了一块堆内存的空间来保存该类中的成员属性
		/*下面要设置类的属性必须要调用方法，因为与之前不同，类的成员属性都加了封装*/
		per.setname ("张三");
		per.setage (18);
		per.tell();
	}
}
 
七、什么是构造方法与匿名对象？：完成对象属性的初始化操作（这样即便没有栈内存的指向操作，也可以使用一次该对象，同样的由于没有栈内存的指向操作，所以该对象使用一次后就将成为垃圾空间）而有了构造方法后就可以在堆内存开辟的同时进行对象实例化处理
 
class Person{
	private String name;
	private int age;
	/*Person的构造方法，可以对成员属性进行初始化，但如果还需要对成员属性进行修改或获取则还需要定义 setter 和 getter 方法 ，这里偷个懒省略了，上面有类似，一般都是要加上的*/
	public Person(String tempname,int  tempage){
		name = tempname;
		age = tempage;
	}
	/*输出方法*/
	public void tell(){ 
		System.out.println("姓名: " + name + "年龄： " + age); 
	}
}
public class JavaDemo{
	public static void main(String args[]){
		Person per = new Person("张三",18);	//声明并实例化对象（但其实也可以不声明直接实例化对象，这就是匿名对象了）
		/*如：new Person("张三"，18).tell 这样代码就简洁了许多，直接一步到位了，但是这种没有指向对象的实例化操作，不好对该类进行后续的操作*/
		per.tell();
	}
}
			
 
八、什么是this关键字？：它表示当前对象的属性和方法
 
 
 
事实上不加this也可以调用类中的属性和方法，但是类中成员属性和方法参数由于表示含义的需要，有可能会产生重名定义的问题。类中的this会随着执行对象的不同而表示不同的实例
 注意：如果一个类中存在了多个构造方法的，并且这些构造方法都使用了this（）相互调用，那么至少保留一个构造方法没有调用其他构造，以作为程序的出口
 
 
九、简单的Java类需要具备哪些条件？
 
 
 
1.类的名称一定要有意义，可以明确的描述某一类事物
 2.类中的所有属性都必须使用pravite进行封装，封装后的属性必须提供setter(),getter()方法
 3.类中可以提供有无数多个的构造方法，但是必须要保留无参构造方法
 4.类中不允许出现任何的输出语句，所有内容的获取必须返回
 5.【可选】可以提供一个获取对象的详细的信息的方法，可以将此方法设置为getInfo()
 
 
/*定义一个描述部门的简单的Java类*/
class Dept {					//满足第一点类的名称是“部门”的英文，可以明确描述某一类事物
	private long deptno;
	private String dname;
	private String loc;
	/*以上满足第二点类中的所有属性都使用了pravite进行了封装*/
	public Dept(){};				//满足了第三点提供了无参构造方法
	public Dept(long deptno,String dname,String loc){	//通过this来调用成员属性，就不用再在构造方法的参数上想新的名字了，这样代码会更简洁易读
		this.deptno = deptno;
		this.dname = dname;
		this.loc = loc;
	}
	public String getIofo(){
		return "【部门信息】部门编号：" + this.deptno + "、部门名称：" + this.dname + "、部门位置：" + this.loc;		//满足第四个条件类中所有内容的获取都用的是返回 
	}
	//setter(),getter()方法省略
}

public class JavaDemo{
	public static void main(String argc[]){
		Dept dept = new Dept(10,"技术部","北京");	//实例化例的对象
		System.out.println(dept.getIofo());		// 获取对象的信息
	}
}

 
程序执行结果：
 
 
十、什么是static关键字？：用于全局属性和全局方法的声明
 
 
 
1.如果想要类中的属性定义为公共属性（所有对象都可以使用的属性），则可以在声明属性前加上static光键字，而当有一个对象修改了static属性内容后，将会影响到所有的对象
 2.static的定义方法？：可以在没有实例化对象的情况下直接调用static定义的属性和方法。static结构可以不受到，对象实例化的限制，并且可以实现多个实例化对象的共享操作
 3.应用案例：对在通过调用进行对象实例化的过程中，可以通过static关键字对对象的个数进行累加处理
 
 
class Chinese{
	private String name;
	private int age;
	static String country = "中华人民共和国";
	public Chinese(String name,int age){
		this.name = name;
		this.age = age;
	}
	//setter(),getter() 省略
	public String getInfo(){
		return "姓名：" + this.name + "、年龄：" + this.age + "、国家：" + this.country ;
	}
}

public class JavaDemo{
	public static void main(String argc[]){
	Chinese perA = new Chinese("张三",18);
	Chinese perB = new Chinese("李四",19);
	Chinese perC = new Chinese("王五",20);
	perA.country = "伟大的中国";//因为country为static属性，当对象perA修改country后，对象preB和preC的country也会跟着被修改
	System.out.println(perA.getInfo());
	System.out.println(perB.getInfo());
	System.out.println(perC.getInfo());
	}
}
/*本程序定义了一个描述中国人的类Chinese，类中country为static（公共属性），即该属性会保存在全局数据当中，当有一个对象修改了static属性内容后将会影响到其他的所有对象*/
 
程序执行后的结果：
 
 
十一、什么是代码块？：使用 { } 定义起来的一段程序
 
 
 
1.什么是普通代码块？：将一个方法中的代码进行分割
 2.什么是构造代码块？：将一个代码块定义在一个类中（每一次实例化新的对象都会调用构造块）
 3.什么是静态代码块？：如果一个构造代码块上使用了Static关键字进行定义的话，那么该代码块就表示静态代码块（静态代码块会优先与构造代码块执行，并且静态代码块中的代码只会执行一次）
 
 
十二、小结
 
 
 
1.面向对象的程序设计是现在主流的程序设计方法，他有三大主要特性：分装性、继承性、多态性
 2.类与对象的关系：类是对象的模板，对象是类的实例（特别注意类只能通过对象才能使用）
 3.**类的组成？😗*成员属性、方法
 4.对象的实例化格式：类名称 + 对象名称 = new + 类名称（） （new用于堆内存空间的开辟）
 5.如果一个对象没有被实例化而直接调用，则使用时会空指向异常（如果是用static关键字定义的，可以被调用一次）
 6.类属于引用数据类型，进行引用传递时，传递的是堆内存的使用权（这句话很重要，之前讲引用传递的时候，绕来绕去，都是这些东西，即一块堆内存可以被多个栈内存所指向，而一块栈内存只能保存一块堆内存的地址）
 7.类的封装性：通过pravite关键字进行修饰，被封装的属性不能被外部直接调用，而只能通过setter或getter()f方法完成。只要是属性，类中属性必须全部封装
 8.构造方法可以为类中的属性进行初始化，构造方法与类的名称相同，无返回值，无类型声明，有封装。如果在类中没有明确定义出构造方法，则自动生成一个无参的什么都不做得构造方法。构造方法可以重载但必须至少有一个
 9.在Java中使用this关键字可以表示当前的对象，可以调用本类中的属性，但调用时要求要放在构造方法的首行
 10.使用static声明的属性和方法可以直接由类名称调用，static属性是所有对象共享的，所有对象都可以对其进行操作
 
 
小小温馨提示：码字不易，希望能一键三连哦🤞🤞🤞