黑马程序员--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:初始化值不同

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

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

<span style="color:#000066;">class student{
int a = 10;//这是成员变量
}
public class studentDemo {
public static void main(String[] args) {
int a = 10;//这是局部变量
}
}</span>

注意事项：

局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则

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();</span>

一: 封装

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();
}
}