Java重修之路(六)面向对象初识,类与对象,成员变量,局部变量,封装,构造函数,构造代码块,this关键字
2016-10-30 16:30
671 查看
今天终于进入正题,Java的面向对象部分,也是Java的核心部分,如果之前只是学过C语言而没有接触其他面向对象的语言的同学,这里要转换思想还是有些难度的,需要多思考,弄清楚什么是面向对象,面向对象与面向过程的区别。不多说废话,开始了。
![](https://oscdn.geek-share.com/Uploads/Images/Content/202009/25/664e0a1c0aa576c8a829327056f458b3)
类是对对象的描述,包括对象的特征,功能。
对象是一个个实体。
在内存中成员变量在堆内存中,因为对象的存在才在内存中存在,而局部变量存在于栈内存中。
这两种写法效果是一样的,但是接下来往下看:
但是对于匿名对象来说,修改属性是没有意义的:
可见属性的修改并没有预期的效果,因为
根本就是操作的两个不同的对象,当执行到第二条语句时,第一个对象已经成为垃圾,第二条语句时重新new了一个对象,并且修改了它的一个属性,但是并没有用,因为修改了也不使用,没有指向它的引用。
特点:
匿名对象操作其属性没有意义,只能调用其方法。
适用场景:
对对象的方法只需要调用一次,可以用匿名对象,这样比较简便,如果需要对多个成员进行调用,必须要有对象引用。
可以将匿名对象作为实际参数传递
两种情况的内存图
![](https://oscdn.geek-share.com/Uploads/Images/Content/202009/25/18de6f8e9f32cdc0e2313f8105473ab8)
两者还有一点区别就是:匿名对象作为实际参数传递,当函数调用完成,生命周期结束,匿名对象又沦为垃圾,而第一种不会。
![](https://oscdn.geek-share.com/Uploads/Images/Content/202009/25/9ab3b7eb7888b83abe5a57b31c2b0eaa)
封装不是私有,私有仅仅是封装的一种表现形式。
![](https://oscdn.geek-share.com/Uploads/Images/Content/202009/25/878b98ab6a1b23564523744924ea2114)
对象一建立就会调用与之对应的构造函数。
由于构造函数的特性,可以在构造函数里面进行初始化。
多个构造函数之间是重载的形式出现的。
每一个类都有一个默认的空参数的构造函数,但是一旦你自己写了构造函数,则默认的构造函数就不存在了。
构造函数和一般方法的区别:
构造函数在对象一建立就执行,一般方法是需要对象主动调用才执行。
一个对象建立,构造函数只执行一次,一般方法可以被对象调用多次。
构造函数适用情景:
对象本身具有的一些特征,在构造函数里面初始化。
和构造函数的区别:
构造代码块是给所有的对象统一初始化,而构造函数是给对应的的对象初始化。
适用情景:对象的公共属性在构造代码块里面统一初始化。
所以必须要有一个关键字,告诉程序将传进来的值赋给本类的成员变量,所以用到关键字this,this代表的是本类。
就能成功赋值。
假设是:
this.name = name;//此时name=传进来的参数
this(name);//name=“abcd” 覆盖掉了
下边这种 情况:
this(name);//
this.name = name;
注意区分。
- 面向对象概述
面向过程是功能行为,就是将功能封装给对象,强调了具备有功能的对象,对象具有一定的特征和功能,在使用的时候只需要找到相应的对象,就能获得其特征和功能。类与对象的关系
类是对对象的描述,包括对象的特征,功能。
对象是一个个实体。
- 成员变量与局部变量
成员变量作用于整个类中,局部变量作用于函数中或者语句中。在内存中成员变量在堆内存中,因为对象的存在才在内存中存在,而局部变量存在于栈内存中。
匿名对象
没有变量名的对象。即没有指向它的引用public class Hello { public static void main(String[] args) { // new Car().run(); Car c=new Car(); c.run(); } public static class Car{ String color="red"; int num=3; public void run(){ System.out.println("color="+color+"\nnum="+num); } } }
这两种写法效果是一样的,但是接下来往下看:
public class Hello { public static void main(String[] args) { // new Car().run(); Car c=new Car(); c.num=5; c.run(); } public static class Car{ String color="red"; int num=3; public void run(){ System.out.println("color="+color+"\nnum="+num); } } } 输出结果为: color=red num=5
但是对于匿名对象来说,修改属性是没有意义的:
public class Hello { public static void main(String[] args) { new Car().num = 5; new Car().run(); } public static class Car { String color = "red"; int num = 3; public void run() { System.out.println("color=" + color + "\nnum=" + num); } } } 输出结果为: color=red num=3
可见属性的修改并没有预期的效果,因为
new Car().num = 5; new Car().run();
根本就是操作的两个不同的对象,当执行到第二条语句时,第一个对象已经成为垃圾,第二条语句时重新new了一个对象,并且修改了它的一个属性,但是并没有用,因为修改了也不使用,没有指向它的引用。
特点:
匿名对象操作其属性没有意义,只能调用其方法。
适用场景:
对对象的方法只需要调用一次,可以用匿名对象,这样比较简便,如果需要对多个成员进行调用,必须要有对象引用。
可以将匿名对象作为实际参数传递
public class Hello { public static void main(String[] args) { // Car c=new Car(); // changeCar(c); changeCar(new Car()); } public static class Car { String color = "red"; int num = 3; public void run() { System.out.println("color=" + color + "\nnum=" + num); } } public static void changeCar(Car c) { c.num = 100; c.color = "aaa"; c.run(); } } 输出结果: color=aaa num=100
两种情况的内存图
两者还有一点区别就是:匿名对象作为实际参数传递,当函数调用完成,生命周期结束,匿名对象又沦为垃圾,而第一种不会。
- 封装
Java三大特性之一public static void show(int x) { check(x); } private static void check(int x) { if (x <= 0) { System.out.println("数据不合法!"); } else { System.out.println(x); } } 在一个类中有这两个方法,只需要将show方法暴露出去给人使用,而check方法时内部检查使用,不需要暴露出去,所以用private修饰。
封装不是私有,私有仅仅是封装的一种表现形式。
public class Person { private int age; private String name; public int getAge() { return age; } public void setAge(int age) { if (age < 0 || age > 200) { System.out.println("年龄不合法!"); return; } this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } } 这里将age,int的权限设为private,所以不能通过对象.属性来设置值,因为外边访问不到,然后对外提供setAge方法,只能通过此方法设置值。
- 构造函数
对象一建立就会调用与之对应的构造函数。
public class Hello { public static void main(String[] args) { new Demo(); } public static class Demo { Demo() { System.out.println("这是构造函数!"); } } } 输出结果: 这是构造函数!
由于构造函数的特性,可以在构造函数里面进行初始化。
多个构造函数之间是重载的形式出现的。
构造函数的重载 public Person() { } public Person(int age) { } public Person(int age, String name) { } public Person(String name, int age) { }
每一个类都有一个默认的空参数的构造函数,但是一旦你自己写了构造函数,则默认的构造函数就不存在了。
构造函数和一般方法的区别:
构造函数在对象一建立就执行,一般方法是需要对象主动调用才执行。
一个对象建立,构造函数只执行一次,一般方法可以被对象调用多次。
构造函数适用情景:
对象本身具有的一些特征,在构造函数里面初始化。
- 构造代码块
给对象化初始化,对象一建立就执行,而且优先于构造函数执行。和构造函数的区别:
构造代码块是给所有的对象统一初始化,而构造函数是给对应的的对象初始化。
适用情景:对象的公共属性在构造代码块里面统一初始化。
- this关键字
首先下边的场景:import javax.print.DocFlavor.STRING; public class Person { private String name; public String getName() { return name; } public void setName(String name) { name = name; } } 这里给name赋值的时候,左边的name指的是本类中的成员变量,右边的name指的是传经来的参数,但是如果按这种写法,name并没有成功赋值:
Person person = new Person(); person.setName("zhangsan"); System.out.println(person.getName()); 输出结果是: null
所以必须要有一个关键字,告诉程序将传进来的值赋给本类的成员变量,所以用到关键字this,this代表的是本类。
public void setName(String name) { this.name = name; }
就能成功赋值。
- this关键字在构造函数之间的调用
public class Person { private int age; private String name; public Person(String name) { this.name = name; } public Person(int age, String name) { // this.name = name; this(name); this.age = age; } } 有两个构造函数,但是设置姓名的构造函数在前边已经有了,此时就可以用this来调用,但是注意: this(name);必须放在最前面,不能放在this.age = age;后边至于为什么,看下边的代码:
import javax.print.DocFlavor.STRING; public class Person { private int age; private String name; public Person(String name) { this.name = "abcd"; } public Person(int age, String name) { // this.name = name; this(name); this.age = age; } }
假设是:
this.name = name;//此时name=传进来的参数
this(name);//name=“abcd” 覆盖掉了
下边这种 情况:
this(name);//
public Person(String name) { this.name = name; }
this.name = name;
注意区分。
相关文章推荐
- 面向对象_成员变量_ 局部变量_匿名对象_封装_构造函数_构造代码块
- 黑马程序员_Java基础_面向对象(概述、类与对象关系、成员变量、封装private、构造函数和构造代码块、this关键字)
- JAVA之旅(四)——面向对象思想,成员/局部变量,匿名对象,封装 , private,构造方法,构造代码块
- 7 面向对象(成员变量和局部变量的区别,类作为形式参数的问题,匿名对象,封装,private关键字,this关键字,构造方法,类的初始化过程,static关键字)
- Java基础05:面向对象;类与对象;匿名对象;成员变量;局部变量;封装;构造函数
- 成员变量和局部变量的区别、方法的形参为类的情况及匿名对象、封装(private关键字)、this关键字、构造方法、static关键字
- JAVA面向对象知识点总结(2)—封装、构造函数、构造代码块、this关键字
- 黑马程序员-博客 (3) 面向对象一之类和对象、成员变量和局部变量、继承、封装、多态
- 黑马程序员:Java之介绍对象、封装、构造函数、构造代码块及this关键字
- 黑马程序员——Java基础---面向对象(面向对象,类,对象,匿名对象,封装,构造函数,构造代码块,this,static,main,帮助文档,静态代码块,单例)
- 面向对象一(类、对象、变量、构造函数、构造代码块、this、static)
- day05面向对象特征,类的变量和方法,封装,构造函数,this关键字
- 面向对象、类与对象、成员与局部变量、封装、private、构造函数、this、static、extends、super、final、abstract、interface、多态、内部类、异常【5】
- JAVA基础再回首(四)——面向对象思想、类与对象、成员/局部变量、匿名对象、封装、private、this、构造方法
- JAVA之旅(四)——面向对象思想,成员/局部变量,匿名对象,封装 , private,构造方法,构造代码块
- 黑马程序员--面向对象(一)封装、成员变量与局部变量、匿名对象、构造函数、this关键字
- 面向对象1【概念】【封装】【构造函数】【代码块】【this关键字】
- 面向对象、匿名对象、成员、封装、主函数、成员变量、局部变量、构造函数、this、静态、主函数
- 【JavaSE学习笔记】面向对象_01(入门,匿名对象,成员变量,局部变量,封装,this,构造方法)
- Java 笔记 及 面向对象 成员变量与局部变量的区别 面向对象3大特征:这里只写了封装,构造函数 .this关键字