黑马程序员--Java学习日记之面向对象(封装,this和static,继承)_黑马程序员代码传智专修学院张三-CSDN博客

本文链接：https://blog.csdn.net/Memor_/article/details/46594385

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