java基础学习_面向对象(上)02_day07总结

============================================================================= =============================================================================

涉及到的知识点有:   1:成员变量和局部变量的区别(理解)   2:类作为形式参数的问题?(理解)   3:匿名对象(理解)   4:封装(理解)   5:private关键字(掌握)   6:this关键字(掌握)   7:构造方法(掌握)     (1)作用     (2)格式     (3)构造方法的注意事项     (4)给成员变量赋值的方式有两种     (5)输出成员变量值的方式有两种     (6)标准学生案例   8:类的初始化过程代码:Student s = new Student();做了哪些事情?(理解)   9:面向对象的练习题(掌握)     (1)标准的手机类的定义和手机测试类。     (2)Demo类中有求和方法,Test类进行测试。     (3)长方形案例。     (4)员工案例。     (5)MyMath案例(自己提供加减乘除并测试)。   10:static关键字(理解)     (0) 针对多个对象有共同的成员变量的时候     (1)静态的意思,可以修饰成员变量和成员方法     (2)静态的特点     (3)静态的内存图     (4)静态的注意事项     (5)静态变量和成员变量的区别     (6)main方法是静态的解释

============================================================================= ============================================================================= 1:成员变量和局部变量的区别(理解) (1)在类中的位置不同:     成员变量:在类中方法外。     局部变量:在方法定义中或者方法声明上(即形参)。 (2)在内存中的位置不同:     成员变量:在堆中。     局部变量:在栈中。 (3)生命周期不同:     成员变量:随着对象的创建而存在,随着对象的消失而消失。     局部变量:随着方法的调用而存在,随着方法的调用完毕而消失。 (4)初始化值不同:     成员变量:有默认值。     局部变量:没有默认值,必须定义,赋值,然后才能使用。 (5)注意事项:

    1.局部变量名称可以和成员变量名称一样,但是在方法中使用该变量的时候,采用的是就近原则(即先找小范围,再找大范围)。     2.局部变量前不能放置任何访问修饰符 (private,public和protected)。final可以用来修饰局部变量。被final修饰的局部变量变为常量了。     3.修饰成员变量的修饰符有:private、默认、protected、public、static、final。

----------------------------------------------------------------------------- 2:类作为形式参数的问题?(理解) (0)之前学的形式参数问题:     基本数据类型(数值型、字符型、布尔型):形式参数的改变不影响实际参数。     引用数据类型(类、接口、数组):形式参数的改变会直接影响实际参数。 (1)如果一个方法的形参的数据类型是一个类时(即引用数据类型),这里的形参其实需要的是该类的一个具体的对象。 如下图所示01:

----------------------------------------------------------------------------- 3:匿名对象(理解)   (1)就是没有名字的对象(是对象的一种简化表示形式)。 (2)匿名对象的应用场景: A:对象调用方法仅仅一次的时候。       注意:调用多次对象的时候,不适合。     那么,这种匿名对象调用方法有什么好处吗?       有,匿名对象调用方法完毕后就是垃圾。可以被垃圾回收器回收,提高内存使用效率。 B:匿名对象可以作为实际参数进行传递。 如下图所示02:

----------------------------------------------------------------------------- 4:封装(理解)   (1)是指隐藏对象的属性和实现细节,仅对外提供公共访问方式。 (2)好处:     A:隐藏实现细节,提供公共的访问方式。     B:提高了代码的复用性。     C:提高了代码的安全性。 (3)设计原则     把不想让外界知道的实现细节给隐藏起来,把属性隐藏,提供公共的访问方式。 (4)private是封装的一种体现之一。 封装体有这几个:       (1)类       (2)方法       (3)private修饰成员变量 ----------------------------------------------------------------------------- 5:private关键字(掌握)   (0)是一个权限修饰符。   (1)私有的意义,可以修饰成员变量和成员方法。(一般来说,private多用来修饰成员变量,少用来修饰成员方法。) (2)特点:     被private修饰的成员只能在本类中被访问。要想访问它,它就要对外提供公共的访问方式。  (3)private的应用:     以后再写一个类的时候:     把所有的成员变量给private了。     提供对应的getXxx()/setXxx()方法。 ----------------------------------------------------------------------------- 6:this关键字(掌握)   (0)name = name; //把自己赋值给自己,没有任何意义。(变量的使用规则:就近原则)   (1)代表当前类的引用对象。简单的记,它就代表当前类的一个具体对象。     记住:哪个对象调用方法,在该方法内部的this就代表哪个对象。 (2)this的应用场景:     A:解决了局部变量隐藏成员变量的问题。     B:其实this还有其他的应用,其他用法后面和super一起讲解。 如下图所示03/04:

----------------------------------------------------------------------------- 7:构造方法(掌握) (1)作用:用于给创建的对象的数据进行初始化。 (2)格式: A:方法名和类名相同。 B:没有返回值类型,连void都不能有。 C:没有具体的返回值。  思考题:构造方法中可不可以有return语句呢?     可以。而是我们写成这个样子就OK了:return;     其实,在任何的void类型的成员方法的最后你都可以写上:return; 表示结束该方法。 (3)构造方法的注意事项: A:如果我们没有给出构造方法,系统将自动提供一个无参构造方法,且是不带修饰符的,即默认修饰符的。 B:如果我们给出了构造方法,不管我们给出的是无参还是有参构造函数,系统将不再提供默认的无参构造方法。 注意:当我们给出了有参构造函数时,但如果我们还想使用无参构造方法,此时就必须自己给出无参构造函数。建议永远自己给出无参构造方法。 C:构造方法也是方法,也可以方法重载的。 (4)给成员变量赋值的方式有两种:(只写一种即可) 方式1:setXxx(参数类型 成员变量名)的成员方法(实际开发时用方式1,该方式更灵活。) 方式2:带一个或者多个参数的构造方法(讲课时用方式2) (5)输出成员变量值的方式有两种:(只写一种即可) 方式1:getXxx() {...}(实际开发时用方式1,该方式更灵活。) 方式2:通过调用show()方法实现(其实方式2一般没有,感觉调用getXxx()输出学生信息比较麻烦,加入一个方法show(),输出学生对象的成员变量信息。) (6)标准学生案例:     类的组成有:成员变量、构造方法、成员方法。     构造方法:没有返回值。     但是也可以在最后写一个return; 其实在任何返回值为void类型的成员方法的最后都可以写上:return;  表示结束该方法。 成员方法的分类: 根据返回值类型可以分为: 1.void类型的成员方法。 2.非void类型的成员方法。 根据形式参数可以分为: 1.无参成员方法  2.有参成员方法 ---------------------------------------

 1 //学生类
 2 class Student {
 3     private String name;
 4     private int age;
 5             
 6     //无参构造方法
 7     public Student() {
 8     }
 9             
10     //有多个参数的构造方法
11     public Student(String name,int age) {
12         this.name = name;
13         this.age = age;
14     }
15             
16     //有明确返回值的、无参的成员方法(单独获取数据)。
17     public String getName() {
18         return name;
19     }
20     //返回void类型的、有参的成员方法。
21     public void setName(String name) {
22         this.name = name;
23     }
24             
25     //有明确返回值的、无参的成员方法(单独获取数据)。
26     public int getAge() {
27         return age;
28     }
29             
30     //返回void类型的、有参的成员方法。
31     public void setAge(int age) {
32         this.age = age;
33     }
34             
35     //输出所有成员变量的值(集体获取数据)
36     public void show() {
37         system.out.println(name+"---"+age);
38     }
39 }
40         
41 //学生测试类
42 class StudentDemo {
43     public static void main(String[] args) {
44         //方式1
45         Student s1 = new Student();
46         s1.setName("林青霞");
47         s1.setAge(27);
48         System.out.println(s1.getName()+"---"+s1.getAge());
49         s1.show();
50                 
51         //方式2
52         Student s2 = new Student("刘意",30);
53         System.out.println(s2.getName()+"---"+s2.getAge());
54         s2.show();
55     }
56 }

----------------------------------------------------------------------------- 8:类的初始化过程代码:Student s = new Student();做了哪些事情?(理解)   (1)把Student.class文件加载到内存,在Student.class文件中找到main方法并放到栈。   (2)在栈内存为s开辟空间(Student s =)。   (3)在堆内存为学生对象申请空间(new Student();)。   (4)给学生的成员变量进行默认初始化。namne = null; age = 0;   (5)给学生的成员变量进行显示初始化。name = 林青霞; age = 27;   (6)通过构造方法给成员变量进行初始化。name = 刘意; age =30;   (7)学生对象初始化完毕后,,把堆内存的地址赋值给栈内存的s变量。 ---------------------------------------

 1 class Student {
 2     private String name = "林青霞";
 3     private int age = 27;
 4     
 5     public Student() {
 6         name = "刘意";
 7         age = 30;
 8     }
 9 }
10 
11 class StudentDemo {
12     public static void main(String[] args) {
13         Student s = new Student();
14     }
15 }

如下图所示05:

----------------------------------------------------------------------------- 9:面向对象的练习题(掌握) (1)标准的手机类的定义和手机测试类。 (2)Demo类中有求和方法,Test类进行测试。     什么时候定义成员变量? 答:当该变量是用来描述一个类的时候。 --------------------------------------- 示例代码如下:

 1 /*
 2     定义一个类Demo,其中定义一个求两个数据和的方法,
 3     定义一个测试类Test,进行测试。
 4     
 5     变量什么时候定义为成员变量?
 6         答:如果这个变量是用来描述这个类的信息的,那么,该变量就应该定义为成员变量。
 7         
 8     变量到底定义在哪里好呢?
 9         答:变量的范围是越小越好。因为能及时的被回收。
10 */
11 //方式1
12 /*
13 class Demo {
14     public int sum() {
15         int a = 10;
16         int b = 20;
17         int c = a + b;
18         return c;
19     }
20 }
21 */
22 //方式1满足了我们的要求,但是不好。
23 //因为参与操作的数据现在是固定的。
24 
25 //方式2
26 /*
27 class Demo {
28     public int sum(int a,int b) {
29         return a + b;
30     }
31 }
32 */
33 //方式2可以满足我们的要求,但是呢我们学习过来面向对象的思想。
34 //我就再想,a,b可不可以定义为成员变量呢?
35 //如果可以,我们再改进一版如下:
36 
37 //方式3
38 class Demo {
39     int a;
40     int b;
41     
42     public int sum() {
43         return a + b;
44     }
45 }
46 //虽然这种方式可以,并且好像是符合了面向对象的思想。
47 //但是不好。
48 //因为我们曾经说过:类是一组相关的属性和行为的集合。
49 //并且类是由事物转换过来的,而类中的成员变量就是事物的属性,属性是用来描述事物的。
50 //同理:成员变量其实是用来描述类的。
51 
52 //测试类
53 class Test {
54     public static void main(String[] args) {
55         //创建对象
56         //方式1测试
57         /*
58         Demo d = new Demo();
59         System.out.println(d.sum());
60         */
61         
62         //方式2测试
63         /*
64         Demo d = new Demo();
65         int a = 10;
66         int b = 20;
67         System.out.println(d.sum(a,b));
68         */
69         
70         //方式3测试
71         Demo d = new Demo();
72         d.a = 10;
73         d.b = 20;
74         System.out.println(d.sum());
75     }
76 }

--------------------------------------- (3)长方形案例。 --------------------------------------- 示例代码如下:

 1 /*
 2     定义一个长方形类,定义求周长和面积的方法,
 3     然后定义一个测试类Test2,进行测试。
 4 
 5     长方形的类:
 6         有成员变量:
 7             长,宽
 8         有成员方法:
 9             求周长:(长+宽)*2;
10             求面积:长*宽
11             
12     注意:
13         import必须出现在所有的class前面。
14 */
15 
16 import java.util.Scanner;
17 
18 class ChangFangXing {
19     //长方形的长
20     private int length;
21     //长方形的宽
22     private int width;
23     
24     //无参构造方法
25     public ChangFangXing(){}
26     
27     //仅仅提供setXxx()即可
28     public void setLength(int length) {
29         this.length = length;
30     }
31     
32     public void setWidth(int width) {
33         this.width = width;
34     }
35     
36     //求周长
37     public int getZhouChang() {
38         return (length + width) * 2;
39     }
40     
41     //求面积
42     public int getArea() {
43         return length * width;
44     }
45 }
46 
47 class Test2 {
48     public static void main(String[] args) {
49         //创建键盘录入对象
50         Scanner sc = new Scanner(System.in);
51         
52         System.out.println("请输入长方形的长:");
53         int length = sc.nextInt();
54         System.out.println("请输入长方形的宽:");
55         int width = sc.nextInt();
56         
57         //创建长方形对象
58         ChangFangXing cfx = new ChangFangXing();
59         //先给成员变量赋值
60         cfx.setLength(length);
61         cfx.setWidth(width);
62         
63         System.out.println("周长是:"+cfx.getZhouChang());
64         System.out.println("面积是:"+cfx.getArea());
65     }
66 }

--------------------------------------- (4)员工案例。     定义一个员工类,自己分析出几个成员变量来,     然后给出成员变量,构造方法,getXxx()/setXxx()方法,     以及一个显示所有成员信息的show()方法。并测试。 (5)MyMath案例(自己提供加减乘除并测试)。     没有成员变量和构造方法,只有成员方法。 ----------------------------------------------------------------------------- 10:static关键字(理解) (0) 针对多个对象有共同的成员变量的时候,     Java就提供了一个关键字来修饰:static。 (1)静态的意思,可以修饰成员变量和成员方法。 (2)静态的特点:     A:随着类的加载而加载。(回想main方法)     B:优先于对象存在。     C:被类的所有对象共享。     这其实也是我们判断该不该使用静态的依据。     举例:饮水机和水杯的问题思考。(成员变量饮水机就用静态来修饰) D:可以通过类名调用。     既可以通过对象名调用,也可以通过类名调用。     建议通过类名调用。     (因为静态修饰的内容一般我们称之为:类成员,与类相关的。)     (不是静态修饰的内容一般我们称之为:对象成员,与对象相关的。) 示例代码如下:

 1 class Student {
 2     //非静态的成员变量
 3     int num = 10;
 4     
 5     //静态的成员变量
 6     static int num2 = 20;
 7 }
 8 
 9 class StudentDemo {
10     public static void main(String[] args) {
11         Student s = new Student();
12         System.out.println(s.num);
13         
14         //通过类名调用
15         System.out.println(Student.num2);
16         //通过对象名调用
17         System.out.println(s.num2);
18     }
19 }

-----------------------------------------------------------------------------   (3)静态的内存图     静态的内容在方法区的静态区。 如下图所示06:

----------------------------------------------------------------------------- (4)静态的注意事项: A:在静态方法中没有this对象。 如何理解呢? 答:因为静态是随着类的加载而加载,而this随着对象的创建而存在。       即静态比对象先存在。 B:静态方法只能访问静态的成员变量和静态的成员方法。 如下图所示07:

----------------------------------------------------------------------------- (5)静态变量和成员变量的区别: A:所属不同       静态变量:属于类,也称为类变量。       成员变量:属于对象,也称为对象变量或实例变量。 B:在内存中的位置不同       静态变量:存储于方法区的静态区。       成员变量:存储于堆内存。 C:生命周期不同       静态变量:静态变量是随着类的加载而加载,随着类的消失而消失。       成员变量:成员变量是随着对象的创建而存在,随着对象的消失而消失。 D:调用不同       静态变量:可以通过对象名调用,也可以通过类名调用。       成员变量:只能通过对象名调用。 -----------------------------------------------------------------------------   (6)main方法是静态的解释     public static void main(String[] args) {...}     public:公共的,访问权限是最大,由于main方法是被jvm调用的,所以权限要够大。     static:静态的,不需要创建对象。通过类名就可以调用,方便jvm的调用。     void:方法的返回值是返回给调用者的,而main方法是被jvm调用的,返回值给jvm没有意义。     main:就是一个常见的名称,是一个常见的程序入口。     String[] args:是一个字符串数组,早期用于接收键盘录入数据,提供程序的灵活性。 格式:java MainDemo hello world java 如下图所示08:

=============================================================================

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏纯洁的微笑

一个高频面试题,考考大家对 Java String 常量池的理解。

作为最基础的引用数据类型,Java 设计者为 String 提供了字符串常量池以提高其性能,那么字符串常量池的具体原理是什么,我们带着以下三个问题,去理解字符串...

2052
来自专栏PHP在线

欢迎来到phpdaily

1.Null类型,表示空对象指针,使用typeof检测会返回object。 如果定义的变量在将来用于保存对象,最好将该变量初始化为NUll.可以体现null作为...

3297
来自专栏码云1024

c++ 深入理解数组

2816
来自专栏和蔼的张星的图像处理专栏

c++ primer2 变量和基本类型。

这四种初始化方式c++11都是支持的。c++11中用花括号来初始化变量得到了全面应用。

1191
来自专栏Play & Scala 技术分享

Scala基础 - 柯里化(Currying)及其应用

3519
来自专栏微信公众号:Java团长

Java基础11 对象引用

我们之前一直在使用“对象”这个概念,但没有探讨对象在内存中的具体存储方式。这方面的讨论将引出“对象引用”(object reference)这一重要概念。

872
来自专栏Python

函数相关知识汇总

一.函数的定义 定义函数的规则: 1.定义:def 关键词开头,空格之后接函数名称和圆括号()。 2.参数:圆括号用来接收参数。若传入多个参数,参数之间用逗号分...

2625
来自专栏机器学习从入门到成神

关于Java中==与equals的解析

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/sinat_35512245/articl...

730
来自专栏从流域到海域

《Java程序设计基础》 第7章手记

本章主要内容 - 类的私有成员与公共成员 - 方法的重载 - 构造方法 - 类的静态成员 - 对象的应用 本节课知识性内容很多,这里...

1849
来自专栏和蔼的张星的图像处理专栏

64. 合并排序数组 II 三指针+从后向前

合并两个排序的整数数组A和B变成一个新的数组。 注意事项 你可以假设A具有足够的空间(A数组的大小大于或等于m+n)去添加B中的元素。 样例 给出A =...

1231

扫码关注云+社区

领取腾讯云代金券