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.有参成员方法
---------------------------------------

//学生类
class Student {
private String name;
private int age;

//无参构造方法
public Student() {
}

//有多个参数的构造方法
public Student(String name,int age) {
this.name = name;
this.age = age;
}

//有明确返回值的、无参的成员方法(单独获取数据)。
public String getName() {
return name;
}
//返回void类型的、有参的成员方法。
public void setName(String name) {
this.name = name;
}

//有明确返回值的、无参的成员方法(单独获取数据)。
public int getAge() {
return age;
}

//返回void类型的、有参的成员方法。
public void setAge(int age) {
this.age = age;
}

//输出所有成员变量的值(集体获取数据)
public void show() {
system.out.println(name+"---"+age);
}
}

//学生测试类
class StudentDemo {
public static void main(String[] args) {
//方式1
Student s1 = new Student();
s1.setName("林青霞");
s1.setAge(27);
System.out.println(s1.getName()+"---"+s1.getAge());
s1.show();

//方式2
Student s2 = new Student("刘意",30);
System.out.println(s2.getName()+"---"+s2.getAge());
s2.show();
}
}

-----------------------------------------------------------------------------
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变量。
---------------------------------------

class Student {
private String name = "林青霞";
private int age = 27;

public Student() {
name = "刘意";
age = 30；
}
}

class StudentDemo {
public static void main(String[] args) {
Student s = new Student();
}
}

如下图所示05：




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

/*
定义一个类Demo,其中定义一个求两个数据和的方法，
定义一个测试类Test，进行测试。

变量什么时候定义为成员变量？
答：如果这个变量是用来描述这个类的信息的，那么，该变量就应该定义为成员变量。

变量到底定义在哪里好呢？
答：变量的范围是越小越好。因为能及时的被回收。
*/
//方式1
/*
class Demo {
public int sum() {
int a = 10;
int b = 20;
int c = a + b;
return c;
}
}
*/
//方式1满足了我们的要求，但是不好。
//因为参与操作的数据现在是固定的。

//方式2
/*
class Demo {
public int sum(int a,int b) {
return a + b;
}
}
*/
//方式2可以满足我们的要求，但是呢我们学习过来面向对象的思想。
//我就再想，a，b可不可以定义为成员变量呢?
//如果可以，我们再改进一版如下：

//方式3
class Demo {
int a;
int b;

public int sum() {
return a + b;
}
}
//虽然这种方式可以，并且好像是符合了面向对象的思想。
//但是不好。
//因为我们曾经说过：类是一组相关的属性和行为的集合。
//并且类是由事物转换过来的，而类中的成员变量就是事物的属性，属性是用来描述事物的。
//同理：成员变量其实是用来描述类的。

//测试类
class Test {
public static void main(String[] args) {
//创建对象
//方式1测试
/*
Demo d = new Demo();
System.out.println(d.sum());
*/

//方式2测试
/*
Demo d = new Demo();
int a = 10;
int b = 20;
System.out.println(d.sum(a,b));
*/

//方式3测试
Demo d = new Demo();
d.a = 10;
d.b = 20;
System.out.println(d.sum());
}
}

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

/*
定义一个长方形类，定义求周长和面积的方法，
然后定义一个测试类Test2，进行测试。

长方形的类：
有成员变量：
长，宽
有成员方法：
求周长：(长+宽)*2;
求面积：长*宽

注意：
import必须出现在所有的class前面。
*/

import java.util.Scanner;

class ChangFangXing {
//长方形的长
private int length;
//长方形的宽
private int width;

//无参构造方法
public ChangFangXing(){}

//仅仅提供setXxx()即可
public void setLength(int length) {
this.length = length;
}

public void setWidth(int width) {
this.width = width;
}

//求周长
public int getZhouChang() {
return (length + width) * 2;
}

//求面积
public int getArea() {
return length * width;
}
}

class Test2 {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);

System.out.println("请输入长方形的长：");
int length = sc.nextInt();
System.out.println("请输入长方形的宽：");
int width = sc.nextInt();

//创建长方形对象
ChangFangXing cfx = new ChangFangXing();
//先给成员变量赋值
cfx.setLength(length);
cfx.setWidth(width);

System.out.println("周长是："+cfx.getZhouChang());
System.out.println("面积是："+cfx.getArea());
}
}

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

class Student {
//非静态的成员变量
int num = 10;

//静态的成员变量
static int num2 = 20;
}

class StudentDemo {
public static void main(String[] args) {
Student s = new Student();
System.out.println(s.num);

//通过类名调用
System.out.println(Student.num2);
//通过对象名调用
System.out.println(s.num2);
}
}

-----------------------------------------------------------------------------
　　(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：



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