黑马程序员--Java学习日记之面向对象(封装,this和static,继承)
——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-
Java基础之面向对象..概述..
面向对象的三大特征:封装,继承,多态
面向对象思想概述
当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。
可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了。这时就开始思索，
能不能把这些步骤和功能在进行封装，封装时根据不同的功能，进行不同的封装，功能类似的封装在一起。
这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。
C:面向对象思想特点
a:是一种更符合我们思想习惯的思想
b:可以将复杂的事情简单化
c:将我们从执行者变成了指挥者
角色发生了转换
面向对象开发
就是不断的创建对象，使用对象，指挥对象做事情
06.04_面向对象(学生类的定义)
A:学生事物
属性: 姓名 , 年龄 , 地址 ...
行为: 吃饭 , 睡觉 , 上课 ...
B:学生事物与学生类的对应关系
属性 ----- 成员变量
行为 ----- 成员方法
class Student {
02.
03. // 成员变量
04. String name = "张三"; // 姓名
05. int age = 24 ; // 年龄
06. String sex = "女"; // 性别
07.
08. // 成员方法
09. // 学习
10. public void study(){
11. System.out.println("学生在学习....");
12. }
13.
14. // 吃饭
15. public void eat(){
16. System.out.println("学习饿了该吃饭了....");
17. }
18.
19. // 睡觉
20. public void sleep(){
21. System.out.println("学习累了该睡觉了....");
22. }
06.11_面向对象(成员变量和局部变量的区别)
A:在类中的位置不同
成员变量：在类中方法外
局部变量：在方法定义中或者方法声明上
B:在内存中的位置不同
成员变量：在堆内存
局部变量：在栈内存
C:生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
D:初始化值不同
成员变量：有默认初始化值
局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。
class student{
int a = 10;//这是成员变量
}
public class studentDemo {
public static void main(String[] args) {
int a = 10;//这是局部变量
}
}注意事项：
局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则
12_面向对象(方法的形式参数是类名的时候如何调用)
A:Java中参数传递问题
形式参数
基本类型：形式参数的改变不影响实际参数
引用类型：形式参数的改变直接影响实际参数
B:方法的参数是类名
如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。
class Student {
03.
04. // 成员变量
05. /*
06. String name = "张三"; // 姓名
07. int age = 24 ; // 年龄
08. String sex = "女" ; // 性别
09. */
10.
11. String name ; // 姓名 // null
12. int age ; // 年龄 // 0
13. String sex ; // 性别 // null
14.
15. // 成员方法
16. // 学习
17. public void study(){
18. System.out.println("学生在学习....");
19. }
20.
21. // 吃饭
22. public void eat(){
23. System.out.println("学习饿了该吃饭了");
24. }
25.
26. // 睡觉
27. public void sleep(){
28. System.out.println("学习累了该睡觉了");
29. }
30.}
31.
32.// 测试类
33.class StudentDemo {
34.
35. public static void main(String[] args){
36.
37. // 创建学生对象
38. // 类名 对象名 = new 类名();
39. Student s = new Student();
40.
41. // 给对象赋值
42. s.name = "张三";
43. s.age = 24 ;
44. s.sex = "男";
45.
46. // 如何获取成员变量
47. // 格式: 对象名.变量名
48. /*
49. String name = s.name ;
50. System.out.println(name);
51. */
52.
53. System.out.println(s.name + "----" + s.age + "----" + s.sex);
54.
55. // 调用成员方法
56. // 格式: 对象名.方法名(...)
57. s.study();
58. s.eat();
59. s.sleep();
60.
61. System.out.println("----------------------------");
62.
63. // 类名 对象名 = new 类名();
64. Student s2 = new Student();
65.
66. // 给成员变量赋值
67. s2.name = "李四";
68. s2.age = 21 ;
69. s2.sex = "女";
70.
71. System.out.println(s2.name + "----" + s2.age + "----" + s2.sex);
72.
73. // 格式: 对象名.方法名(...)
74. s2.study();
75. s2.eat();
76. s2.sleep();
一: 封装
06.14_面向对象(封装的概述)
A:封装的引入
通过学生案例，给年龄赋值为负数引出数据问题。
然后通过private解决这个问题。最后说其实这就是封装。
B:封装概述
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
C:封装好处
隐藏实现细节，提供公共的访问方式
提高了代码的复用性
提高安全性。
D:封装原则
将不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共方法对其访问。
06.15_面向对象(private关键字的概述和特点)
A:private关键字特点
a:是一个权限修饰符
b:可以修饰成员变量和成员方法
c:被其修饰的成员只能在本类中被访问
A:private最常见的应用：
(1):把成员变量用private修饰
(2):提供对应的getXxx()和setXxx()方法
06.17_面向对象(this关键字的概述和应用)
A:为什么要有this
当我们的局部变量和成员变量相同的时候,如果我们不使用this关键字,那么会导致一个问题:就是局部变量隐藏了成员变量的问题
B:this关键字特点
是当前类的对象引用。
简单的记，它就代表当前类的一个对象。谁调用这个方法,那么该方法的内部的this就代表谁
C:this的应用场景
解决局部变量隐藏成员变量
// 定义一个学生类
class Student {
// 成员变量
private String name ; // 姓名
private int age ; // 年龄
// 提供对应的get和set方法
public String getName(){
// return name ; // 存在一个隐含的this
return this.name ;
}
public void setName(String name){
// 我们变量的访问遵循一个"就近原则"
// 我们需要的是将传递进来的name赋值给成员变量的name
// name = name ;
// 我们要访问成员变量需要使用对象对其访问,那么谁又可以代表当前类的一个对象呢?
// 这时候java就给我们提供了一个关键字: this
this.name = name ;
}
public int getAge(){
return age ;
}
public void setAge(int age){
this.age = age ;
}
}
// 测试类
class StudentDemo {
public static void main(String[] args){
// 创建学生对象
Student s = new Student();
// 给成员变量赋值
s.setName("小菲菲");
s.setAge(13);
// 输出所有的成员变量
System.out.println(s.getName() + "---" + s.getAge());
// 创建学生对象
Student s1 = new Student();
// 给成员变量赋值
s1.setName("大菲菲");
s1.setAge(18);
// 输出所有的成员变量
System.out.println(s1.getName() + "---" + s1.getAge());
}
}构造方法
构造方法就是创建对象,给对象中的成员进行初始化用的。
※构造方法的格式特点
a:方法名与类名相同
b:没有返回值类型，连void都没有
c:没有具体的返回值
// 手机类
class Phone {
// 成员变量
private String brand ; // 品牌
private String color ; // 颜色
private int price ; // 价格
// 构造方法
public Phone(){}
public Phone(String brand , String color , int price){
this.brand = brand ;
this.color = color ;
this.price = price ;
}
// 提供get和set方法
public String getBrand(){
return brand ;
}
public void setBrand(String brand){
this.brand = brand ;
}
public String getColor(){
return color ;
}
public void setColor(String color){
this.color = color ;
}
public int getPrice(){
return price ;
}
public void setPrice(int price){
this.price = price ;
}
}
// 测试类
class PhoneDemo {
public static void main(String[] args){
// 创建手机对象方式1
Phone p = new Phone();
// 给成员变量赋值
p.setBrand("苹果");
p.setColor("白色");
p.setPrice(100);
// 获取成员变量
System.out.println(p.getBrand() + "---" + p.getColor() + "---" + p.getPrice());
System.out.println("----------------------------------");
// 创建手机对象方式2
Phone p2 = new Phone("三星" , "黑色" , 50);
// 获取成员变量
System.out.println(p2.getBrand() + "---" + p2.getColor() + "---" + p2.getPrice());
}
}我们还需要注意两个事项：
1.如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
2.如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法
五、static关键字
这里先讲讲static关键字的特点
1.随着类的加载而加载
2.优先于对象存在
3.被类的所有对象共享。举例：咱们班级的学生应该共用同一个班级编号。其实这个特点也是在告诉我们什么时候使用静态?如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
4.可以通过类名调用，其实它本身也可以通过对象名调用。推荐使用类名调用。静态修饰的内容一般我们称其为：与类相关的，类成员
程序：
// 人类
class Person {
// 成员变量
String name ; // 姓名
// String country ; // 国籍
static String country ;
public void show(){
System.out.println(name + "---" + country);
}
}
// 测试类
class PersonDemo {
public static void main(String[] args){
// 创建一个对象
Person p = new Person();
// 给成员变量赋值
p.name = "凤姐";
p.country = "中国";
// 调用show方法
p.show();
// 创建第二个对象
Person p2 = new Person();
//给成员变量赋值
p2.name = "刘亦菲";
// p2.country = "中国";
// 调用show方法
p2.show();
System.out.println("-----------------------");
p.country = "美国";
p.show();
p2.show();
}
}1
六、继承
继承使用extends关键字，它的好处是：
1.提高了代码的复用性；
2.让类与类之间产生了关系，给第三个特征多态提供了前提；
3.提高了代码的维护性；
（1）引出
继承其它类的类叫”子类”，被继承的类叫”父类”、”超类”、”基类”，当子类继承了父类后，就自动拥有了父类中允许被继承的成员；大家可以近似的认为：子类就是拥有了父类中的可以被继承的成员。
如下程序所示：
class Person
{
String name;//姓名
int age;//年龄
char sex;//性别
void show(){
System.out.println("我是传智播客的一员，我骄傲！！");
}
}
//Person的"子类"
class Student extends Person
{
String stuNo;//学员编号
int score;//分数；
}
//Person的"子类"
class Teacher extends Person
{
String teaNo;//教师编号
}
//当再需要"员工类"时，也需要这些成员时，可以直接继承自"Person"
class Employee extends Person
{
//自动拥有了Person的三个属性和一个方法；
}
class Demo
{
public static void main(String[] args)
{
Student stu = new Student();
System.out.println(stu.name);//继承的
System.out.println(stu.age);//继承的
System.out.println(stu.sex);//继承的
System.out.println(stu.stuNo);//自己的
stu.show();
Teacher tea = new Teacher();
System.out.println(tea.name);//继承的
System.out.println(tea.age);//继承的
System.out.println(tea.sex);//继承的
System.out.println(tea.teaNo);//自己的
tea.show();
}
}1
在java中只支持单继承，不支持多继承的，但可以支持多层继承。
（2）继承的注意事项
1.子类不能继承父类中私有成员：
2.构造方法是不能被继承的；
3.当实例化一个子类对象时，会调用父类的构造方法，实例化一个父类对象；这个父类对象，是存储在子类对象空间内的。
4.不要为了部分功能而去继承：
5.当类和类之间是：是一个(is a)的关系时，使用继承，学员是传智播客的一员，教师是传智播客的一员，所以，Student可以继承自Person，Teacher也可以继承自Person
代码：
class A
{
String name;
private int age;//此成员不会被子类继承
private void show(){//此方法不会被子类继承
System.out.println("private的show()");
}
void show2(){
System.out.println("非私有的show2()");
}
A(){
System.out.println("A的构造方法");
}
}
class B extends A
{
B(){
System.out.println("B的构造方法");
}
}
class Demo
{
public static void main(String[] args)
{
B b = new B();
// System.out.println(b.name);//OK的，name可以被继承
// System.out.println(b.age);//NO的，编译错误，age私有的，不能被继承
// b.show();///NO的，编译错误，show私有的，不能被继承
// b.show2();//OK的，show2可以被继承
B b2 = new B();
}
}（3）继承中成员变量的关系
1.首先在子类局部范围找
2.然后在子类成员范围找
3.最后在父类成员范围找(肯定不能访问到父类局部范围)
4.如果还是没有就报错。(不考虑父亲的父亲…)
class A
{
int num = 10;
}
class B extends A
{
int a = 20;
int num = 30;//子类成员变量，覆盖父类的成员变量；
void show(){
//就近原则；
int num = 40;//局部变量，覆盖成员变量
System.out.println("num = " + num);//40 注意：先找局部，再找成员，再找父类；
System.out.println("this.num = " + this.num);//30，注意：如果本类没有，会向父类去找；
System.out.println("super.num = " + super.num);//访问父类的num : 10
}
}
class Demo
{
public static void main(String[] args)
{
B b = new B();
//在外部访问B中的成员变量
/*
System.out.println(b.num);
System.out.println(b.a);
*/
b.show();
}
}