JavaSE学习总结第07天_面向对象2

07.01 成员变量和局部变量的区别

1.在类中的位置不同

成员变量    类中方法外

局部变量    方法内或者方法声明上

2.在内存中的位置不同

成员变量   堆内存

局部变量   栈内存

3.生命周期不同

成员变量   随着对象的存在而存在，随着对象的消失而消失

局部变量   随着方法的调用而存在，随着方法的调用完毕而消失

4.初始化值不同

成员变量   有默认的初始化值

局部变量   没有默认的初始化值，必须先定义，赋值，才能使用。

07.02 方法的形式参数是类名的调用

例:

 1 class Demo
 2 {
 3     public static void main(String[] args)
 4     {
 5         //创建学生对象
 6         Student s = new Student();
 7         StudentDemo sd = new StudentDemo();
 8         sd.method(s);
 9     }
10 }
11 class StudentDemo
12 {
13     //形式参数是引用类型
14     public void method(Student s)
15     {
16         s.show();
17     }
18 }
19 class Student
20 {
21     public void show()
22     {
23         System.out.println("学生爱学习");
24     }
25 }

07.03 匿名对象的概述和应用

匿名对象:就是没有名字的对象。是对象的一种简化表示形式

匿名对象的两种使用情况:

1.对象调用方法仅仅一次的时候

2.作为实际参数传递

例:

 1 class Demo
 2 {
 3     public static void main(String[] args)
 4     {
 5         //匿名对象调用方法
 6         new Student().show();
 7     }
 8 }
 9 class Student
10 {
11     public void show()
12     {
13         System.out.println("学生爱学习");
14     }
15 }

匿名对象调用完毕就是垃圾，垃圾回收器会在适当的时间回收，提高内存的使用效率

07.04 封装的概述

封装概述:是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

例:

 1 class Student
 2 {
 3     String name;
 4     //将age私有，只能在Student类中访问
 5     private int age; 
 6 
 7     //提供对外访问的方法获取age的值
 8     public int getAge()
 9     {
10         return age;
11     }
12     //提供对外访问的方法，并可以对传入的a的值进行判断，满足条件则赋值给age，不满足则不赋值
13     public void setAge(int a)
14     {
15         age = a;
16     }
17     public void show()
18     {
19         System.out.println("姓名:"+name+"   "+"年龄:"+age);
20     }
21 }

07.05 封装的好处和设计原则

封装好处:

1.隐藏实现细节，提供公共的访问方式

2.提高了代码的复用性

3.提高安全性

封装原则:将不需要对外提供的内容都隐藏起来。把属性隐藏，提供公共方法对其访问。

07.06 private关键字的概述和特点

private关键字:是一个权限修饰符。可以修饰成员(成员变量和成员方法)，被private修饰的成员只在本类中才能访问。

private最常见的应用:

1.把成员变量用private修饰

2.提供对应的getXxx()/setXxx()方法

07.07 private的应用标准案例

 1 class Demo
 2 {
 3     public static void main(String[] args)
 4     {
 5         Student s = new Student();
 6         //给成员变量赋值
 7         s.setName("小强");
 8         s.setAge(25);
 9 
10         System.out.println(s.getName()+":"+s.getAge());
11     }
12 }
13 class Student
14 {
15     private String name;
16     //将age私有，只能在Student类中访问
17     private int age; 
18 
19     //提供对外访问的方法获取name的值
20     public String getName()
21     {
22         return name;
23     }
24     //提供对外访问的方法设置name的值
25     public void setName(String n)
26     {
27         name = n;
28     }
29     //提供对外访问的方法获取age的值
30     public int getAge()
31     {
32         return age;
33     }
34     //提供对外访问的方法设置age的值
35     public void setAge(int a)
36     {
37         age = a;
38     }
39 }

07.08 this关键字的概述和应用

this:代表所在类的对象引用

方法被哪个对象调用，this就代表那个对象

当局部变量隐藏成员变量时使用this

例:

 1 class Student
 2 {
 3     private String name;
 4     //将age私有，只能在Student类中访问
 5     private int age; 
 6 
 7     //提供对外访问的方法获取name的值
 8     public String getName()
 9     {
10         return name;
11     }
12     //提供对外访问的方法设置name的值
13     public void setName(String name)
14     {
15         this.name = name;
16     }
17     //提供对外访问的方法获取age的值
18     public int getAge()
19     {
20         return age;
21     }
22     //提供对外访问的方法设置age的值
23     public void setAge(int age)
24     {
25         this.age = age;
26     }
27 }

07.09 this关键字的内存图解

07.10 标准的手机类代码及其测试

 1 class Demo
 2 {
 3     public static void main(String[] args)
 4     {
 5         Phone p = new Phone();
 6         System.out.println("品牌:"+p.getBrand()+" 价格:"+p.getPrice()+" 颜色:"+p.getColor());
 7         p.setBrand("小米");
 8         p.setPrice(1999);
 9         p.setColor("白色");
10         System.out.println("品牌:"+p.getBrand()+" 价格:"+p.getPrice()+" 颜色:"+p.getColor());
11     }
12 }
13 class Phone
14 {
15     private String brand;//品牌
16     private int price;//价格 
17     private String color;//颜色
18 
19     public String getBrand()
20     {
21         return brand;
22     }
23     public void setBrand(String brand)
24     {
25         this.brand = brand;
26     }
27 
28     public int getPrice()
29     {
30         return price;
31     }
32     public void setPrice(int price)
33     {
34         this.price = price;
35     }
36 
37     public String getColor()
38     {
39         return color;
40     }
41     public void setColor(String color)
42     {
43         this.color = color;
44     }
45 }

运行结果:

品牌:null 价格:0 颜色:null
品牌:小米价格:1999 颜色:白色

07.11 构造方法概述和格式

构造方法作用概述:给对象的数据进行初始化

构造方法格式:

1.方法名与类名相同

2.没有返回值类型，连void都没有

3.没有具体的返回值

例:

07.12 构造方法的重载及注意事项

构造方法注意事项:

1.如果不提供构造方法，系统会给出默认构造方法

2.如果提供了构造方法，系统将不再提供

3.构造方法也是可以重载的

07.13 成员方法的分类及使用

方法具体划分:

根据返回值:1.有明确返回值方法    2.返回void类型的方法

根据形式参数:1.无参方法     2.带参方法

例:

 1 class Demo
 2 {
 3     public static void main(String[] args)
 4     {
 5         Student s = new Student();
 6         String str = s.getString();
 7         System.out.println(str);
 8         s.show();
 9         s.method("小强");
10     }
11 }
12 class Student
13 {
14     private String name;
15     private int age;
16     //有明确返回值的无参方法
17     public String getString()
18     {
19         return "hello";
20     }
21     //返回void类型的无参方法
22     public void show()
23     {
24         System.out.println("show run");
25     }
26     //返回void类型的带参方法
27     public void method(String name)
28     {
29         System.out.println("name:"+name);
30     }
31 }

07.14 一个标准学生类的代码及测试

类的组成:

1.成员变量

2.构造方法[无参构造方法 / 带参构造方法]

3.成员方法[getXxx() / setXxx()]

给成员变量赋值的方式

1.无参构造方法 + setXxx()

2.带参构造方法

 1 /*
 2 学生类:
 3         成员变量:name，age
 4         构造方法:无参，带两个参
 5         成员方法:getXxx()/setXxx()
 6         show():输出该类的所有成员变量值
 7             
 8     给成员变量赋值:
 9         A:setXxx()方法
10         B:构造方法
11         
12     输出成员变量值的方式:
13         A:通过getXxx()分别获取然后拼接
14         B:通过调用show()方法搞定
15 */
16 //测试类
17 class Demo
18 {
19     public static void main(String[] args)
20     {
21         //方式1给成员变量赋值
22         //无参构造+setXxx()
23         Student s1 = new Student();
24         s1.setName("小明");
25         s1.setAge(27);
26         //输出值
27         System.out.println(s1.getName()+"---"+s1.getAge());
28         System.out.println("----------------------------");
29         
30         //方式2给成员变量赋值
31         Student s2 = new Student("小强",30);
32         s2.show();
33     }
34 }
35 
36 class Student 
37 {
38     //姓名
39     private String name;
40     //年龄
41     private int age;
42     
43     //构造方法
44     public Student() 
45     {
46     }
47     
48     public Student(String name,int age) 
49     {
50         this.name = name;
51         this.age = age;
52     }
53     
54     public String getName() 
55     {
56         return name;
57     }
58     
59     public void setName(String name) 
60     {
61         this.name = name;
62     }
63     
64     public int getAge() 
65     {
66         return age;
67     }
68     
69     public void setAge(int age) 
70     {
71         this.age = age;
72     }
73     
74     //输出所有的成员变量值
75     public void show() 
76     {
77         System.out.println(name+"---"+age);
78     }
79 }

07.15 一个标准的手机的代码及测试

 1 //测试类
 2 class Demo
 3 {
 4     public static void main(String[] args)
 5     {
 6         //创建对象
 7         Phone p = new Phone();
 8         
 9         //给成员变量赋值
10         p.setBrand("小米");
11         p.setPrice(2299);
12         p.setColor("白色");
13         
14         //获取值
15         System.out.println(p.getBrand()+"---"+p.getPrice()+"---"+p.getColor());
16     }
17 }
18 
19 //定义手机类
20 class Phone
21 {
22     //品牌
23     private String brand;
24     //价格
25     private int price;
26     //颜色
27     private String color;
28     
29     //无参构造方法
30     public Phone() 
31     {
32     }
33     
34     //getXxx()和setXxx()方法
35     public String getBrand() 
36     {
37         return brand;
38     }
39     public void setBrand(String brand) 
40     {
41         this.brand = brand;
42     }
43     
44     public int getPrice() 
45     {
46         return price;
47     }
48     public void setPrice(int price)
49     {
50         this.price = price;
51     }
52     
53     public String getColor() 
54     {
55         return color;
56     }
57     public void setColor(String color) 
58     {
59         this.color = color;
60     } 
61 }

07.16 创建对象做了哪些事情

Student s = new Student();在内存中做了哪些事情?

1.加载Student.class文件进内存

2.在栈内存为s开辟空间

3.在堆内存为学生对象开辟空间

4.对学生对象的成员变量进行默认初始化

5.对学生对象的成员变量进行显示初始化

6.通过构造方法对学生对象的成员变量赋值

7.学生对象初始化完毕，把对象地址赋值给s变量

07.17 什么时候定义成员变量

如果这个变量是用来描述这个类的信息的，那么，该变量就应该定义为成员变量。变量的范围越小越好，因为能及时的被回收。

07.18 长方形案例练习

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

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

07.19 员工类案例练习

 1 /*
 2 成员变量:员工编号，姓名，年龄
 3 构造方法:无参构造方法
 4 成员方法:
 5          getXxx()/setXxx();
 6          show();
 7 */
 8 
 9 class Employee 
10 {
11     //员工编号
12     private String employeeId;
13     //姓名
14     private String name;
15     //年龄
16     private int age;
17     
18     //构造方法
19     public Employee() 
20     {
21     }
22     
23     //getXxx()/setXxx()
24     public String getEmployeeId() 
25     {
26         return employeeId;
27     }
28     
29     public void setEmployeeId(String employeeId) 
30     {
31         this.employeeId = employeeId;
32     }
33     
34     public String getName() 
35     {
36         return name;
37     }
38     
39     public void setName(String name) 
40     {
41         this.name = name;
42     }
43     
44     public int getAge() 
45     {
46         return age;
47     }
48     
49     public void setAge(int age) 
50     {
51         this.age = age;
52     }
53     
54     //显示所有成员信息的方法
55     public void show() 
56     {
57         System.out.println("员工编号:"+employeeId+"  姓名:"+name+"  年龄:"+age);
58     }
59 }
60 
61 //测试类
62 class Demo
63 {
64     public static void main(String[] args)
65     {
66         //创建对象
67         Employee e = new Employee();
68         
69         //给成员变量赋值
70         e.setEmployeeId("ID8899");
71         e.setName("旺财");
72         e.setAge(18);
73         
74         //获取数据
75         //System.out.println(e.getEmployeeId()+"---"+e.getName()+"---"+e.getAge());
76     
77         //使用show方法
78         e.show();
79     }
80 }

07.20 实现加减乘除并测试

 1 import java.util.Scanner;
 2 class MyMath 
 3 {
 4     //加法功能
 5     public int add(int a,int b) 
 6     {
 7         return a + b;
 8     }
 9     
10     //减法功能
11     public int sub(int a,int b) 
12     {
13         return a - b;
14     }
15     
16     //乘法功能
17     public int mul(int a,int b)
18     {
19         return a * b;
20     }
21     
22     //除法功能
23     public int div(int a,int b) 
24     {
25         return a / b;
26     }
27 }
28 
29 //测试类
30 class Demo
31 {
32     public static void main(String[] args)
33     {
34         //创建键盘录入对象
35         Scanner sc = new Scanner(System.in);
36         
37         System.out.println("请输入第一个操作数:");
38         int num1 = sc.nextInt();
39         System.out.println("请输入第二个操作数:");
40         int num2 = sc.nextInt();
41         
42         //创建MyMath对象，并使用
43         MyMath mm = new MyMath();
44         
45         System.out.println(num1+"+"+num2+"="+mm.add(num1,num2));
46         System.out.println(num1+"-"+num2+"="+mm.sub(num1,num2));
47         System.out.println(num1+"*"+num2+"="+mm.mul(num1,num2));
48         System.out.println(num1+"/"+num2+"="+mm.div(num1,num2));
49     }
50 }

运行结果:

请输入第一个操作数:
8
请输入第二个操作数:
2
8+2=10
8-2=6
8*2=16
8/2=4

07.21 static关键字的引入

例:

 1 class Person
 2 {
 3     String name;
 4     //使用static修饰的数据称为对象的共享数据
 5     static String country = "中国";
 6     public void show()
 7     {
 8         System.out.println("姓名:"+name+"  国家:"+country);
 9     }
10 }
11 
12 class Demo
13 {
14     public static void main(String[] args)
15     {
16         Person p1 = new Person();
17         p1.name = "小明";
18         p1.show();
19 
20         Person p2 = new Person();
21         p2.name = "小红";
22         p2.country = "美国";
23         p2.show();
24         p1.show();
25 
26     }
27 }

运行结果:

姓名:小明  国家:中国
姓名:小红  国家:美国
姓名:小明  国家:美国

07.22 static关键字的特点

1.static是一个修饰符，用于修饰成员(成员变量和成员函数)

2.static修饰的成员被所有的对象共享

3.static优先于对象存在，因为static成员随着类的加载就已经存在了

4.static修饰的成员可以被对象调用，也可以直接被类名调用，格式为：类名.静态成员

5.static修饰的数据是共享数据，对象中存储的是特有数据

07.23 static的内存图解

07.24 static的注意事项

1.在静态方法中是没有this关键字的

2.静态方法只能访问静态的成员变量和静态的成员方法

3.主函数是静态的，如果要在主函数中调用非静态成员可以创建一个对象来调用

07.25 静态变量和成员变量的区别

1.所属不同

静态变量属于类，所以也称为为类变量

成员变量属于对象，所以也称为实例变量(对象变量)

2.内存中位置不同

静态变量存储于方法区的静态区

成员变量存储于堆内存

3.内存出现时间不同

静态变量随着类的加载而加载，随着类的消失而消失

成员变量随着对象的创建而存在，随着对象的消失而消失

4.调用不同

静态变量可以通过类名调用，也可以通过对象调用

成员变量只能通过对象名调用

07.26 main方法的格式详细解释