Java编程基础07——面向对象_类&private&this

摘要：面向对象思想概述了解面向对象开发就是不断的创建对象，使用对象，指挥对象做事情。面向对象设计其实就是在管理和维护对象之间的关系。建议文件名称和测试类名称一致。

A:面向对象开发就是不断的创建对象，使用对象，指挥对象做事情。

B:面向对象设计其实就是在管理和维护对象之间的关系。

C:面向对象特征封装(encapsulation)、继承(inheritance)、多态(polymorphism)

类是对某一类事物共性的抽象概念，而对象描述的是一个具体的产物。
每一个属性的集合就构成了一个对象，但是所有的属性都应该是群体的定义，而群体的定义就形成了一个类。
类是一个模板，而对象才是类可以使用的实例。

在类之中一般会有两个组成：

成员属性：（Field）有时候会简化成其为属性比如——年龄，姓名，性别
操作方法：（Method）定义对象具有的处理行为比如——唱歌、跳舞、游泳、运动

A:我们学习编程是为了什么

为了把我们日常生活中实物用学习语言描述出来

B:我们如何描述现实世界事物

属性 就是该事物的描述信息(事物身上的名词)

行为 就是该事物能够做什么(事物身上的动词)

C:Java中最基本的单位是类,Java中用class描述事物也是如此

成员变量 就是事物的属性

成员方法 就是事物的行为

D:定义类其实就是定义类的成员(成员变量和成员方法)

a:成员变量 和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。

b:成员方法 和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。

A:文件名问题

在一个java文件中写两个类：一个基本的类，一个测试类。

建议：文件名称和测试类名称一致。

B:如何使用对象?

创建对象并使用

格式：类名 对象名 = new 类名();

对象名,其实就是合法的标识符:如果是一个单词,所有字母小写;如果多个单词,从第二个单词开始首字母大写

C:如何使用成员变量呢?

对象名.变量名

D:如何使用成员方法呢?

对象名.方法名(...)

* 属性:姓名,年龄,性别
* 行为:学习,睡觉

class JavaObject {
    public static void main(String [] args) {
        //类名 对象名 = new 类名();
        Student s = new Student();
        //调用属性并赋值
        s.name = "张三";
        s.age = 23;
        s.gender = "男";
        System.out.println(s.name + "..." + s.age + "..." + s.gender);   //使用变量

        //调用方法
        s.study();
        s.sleep();
    }
}

class Student {
    String name;        //姓名
    int age;            //年龄属性
    String gender;        //性别属性

    public void study() {   //定义学习的方法；
        System.out.println("学生学习");
    }
    public void sleep() {
        System.out.println("学生睡觉");
    }
}

* 车
* 成员变量：颜色，轮胎数
* 成员方法：跑

    class JavaObject {
        public static void main(String [] args) {
            Car c = new Car();  //创建对象
            c.color = "red";//调用属性并赋值
            c.num = 4;
            c.run();//调用方法

            Car c2 = new Car();
            c2.color = "black";
            c2.num = 3 ;
            c2.run();

            c2 = null;  //当引用设置为null，空指针异常。
            c2.run();

            Car c3 = c2;
            c2.run();
        }
    }
    class Car {
        String color;        //颜色
        int num;            //轮胎数
        public void run() { 
            System.out.println("color" + num);
        }
    }

A:在类中的位置不同

成员变量：在类中方法外

局部变量：在方法定义中或者方法声明上

B:在内存中的位置不同

成员变量：在堆内存(成员变量属于对象,对象进堆内存)

局部变量：在栈内存(局部变量属于方法,方法进栈内存)

C:生命周期不同

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

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

D:初始化值不同

成员变量：有默认初始化值（null或0）

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

注意事项：

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

基本数据类型变量包括哪些:byte,short,int,long,float,double,boolean,char

引用数据类型变量包括哪些:数组,类,接口,枚举

class JavaObject {
    public static void main(String [] args) {
        Person p = new Person();
        p.speak();
    }
}
class Person {
    String name;                //成员变量
    int num;
    public void speak() {  //x和num都是局部变量
        int num = 10;
        System.out.println(num);    
        System.out.println(name);  //就近原则
    }
}

A:方法的参数是类名public void print(Student s){}//print(new Student());

如果你看到了一个方法的形式参数是一个类(引用数据类型)，这里其实需要的是该类的对象（new地址值）。

(~ 记住: 引用数据类型当做形式参数的时候给的是地址值;二基本数据类型当做形参的时候给的是值)

class JavaObject {
    public static void main(String [] args) {
        print(10);   //赋值
        Student s = new Student();  //创建对象
        print(s);

    }
    public static void print(int x) {  //形式参数是基本数据类型，传递的值
        System.out.println(x);
    }
    //形式参数是引用数据类型，传递的地址值
    public static void print(Student stu) {  //Student stu = new Student();
        stu.name = "张三";
        stu.age = 23;
        stu.speak();
    }
}
class Student {
    String name;                //成员变量
    int age;
    public void speak() {  //局部变量
        System.out.println(name + "..." + age);            
    }
}   

没有名字的对象叫做匿名对象；

只适合调用一次的时候。优点是节省代码，调用完毕就是垃圾，可以被垃圾回收器回收。

a:调用方法

class JavaObject {
    public static void main(String [] args) {
        //Car c1 = new Car();  //创建有名字的对象
        //c1.run();

        //new Car().run();   //匿名对象调用完就变成垃圾了
        //new Car().run();   //匿名对象只适合对方法的一次调用,因为调用多次就会产生多个对象,不如用有名字对象,否则浪费内存
        //匿名对象可以调用属性,但是没有意义,因为调用后就变成垃圾,如果需要赋值还是用有名字对象
        new Car().color = "red";
        new Car().num = 23;
        new Car().run();
        }
}
class Car {
    String color;
    int num;
    public void run() {
        System.out.println(color + "..." + num);
    }
}

b:匿名对象可以作为实际参数传递

 class JavaObject {
    public static void main(String [] args) {
        /*Car c1 = new Car();  //创建有名字的对象
        c1.color = "red";
        c1.num = 8;
        c1.run();*/

        //Car c1 = new Car();
        //method(c1);
        //method(new Car());

        //Car c2 = new Car();
        //method(c2);
        //method(new Car());

        for (int i = 0;i < 10 ;i ++ ) {
            method(new Car());
        }
    }
    //抽取方法,提高代码的复用性 protected  default
    public static void method(Car cc) { //Car cc = new Car();
        cc.color = "red";
        cc.num = 8;
        cc.run();
    }
}

A:封装概述

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

B:封装好处

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

提高了代码的复用性

提高安全性。

C:封装原则

将不需要对外提供的内容都隐藏起来。

把属性隐藏，提供公共方法对其访问。

A:人类赋值年龄的问题

B:private关键字特点

a:是一个权限修饰符

b:可以修饰成员变量和成员方法

c:被其修饰的成员只能在本类中被访问

C:案例演示

封装和private的应用：

A:把成员变量用private修饰

B:提供对应的getXxx()和setXxx()方法

private仅仅是封装的一种体现形式,不能说封装就是私有(讲包时会有更好的理解)

public class JavaObject {
    public static void main(String [] args) {
        System.out.println("");
            Person p1 = new Person();
            p1.name = "张三";
            //p1.age = 23;
            //p1.speak();
            p1.setAge(-17);
            //int age1 = p1.getAge();
            System.out.println(p1.getAge());
    }
}
class Person {
    String name;
    private int age;         //私有成员变量
    public void setAge(int a) {  //a = 17 //对外提供公共的访问方法
        if (a > 18 && a<120) {
            age = a;
        } else {
            System.out.println("输入有误");
        }
    }
    public int getAge() {  //对外提供公共的访问方法
        return age;
    }
    public void speak() {
        System.out.println(name + "..." + age);
    }
}   

A:this关键字特点

代表当前对象的引用 (谁来调用我,我就代表谁)

B:案例演示

this的应用场景

用来区分成员变量和局部变量重名,调用成员变量

public class JavaObject {
    public static void main(String [] args) {
        System.out.println("");
            Person p1 = new Person();
            p1.setName("张三");
            p1.setAge(23);
            System.out.println(p1.getName() + "..." + p1.getAge());
            Person p2 = new Person();
            p2.setName("李四");
            p2.setAge(32);
            p2.speak();
    }
}
class Person {
    private String name;
    private int age;
    public void setName(String name) {
        this.name = name;//在这里this代表p1的地址值
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {  //a = 17
        if (age > 18 && age<120) {
            this.age = age;
        } else {
            System.out.println("输入有误");
        }
    }
    public int getAge() {
        return age;
    }

    public void speak() {
        System.out.println(name + "..." + age);
    }
}  

把手机类写成一个标准类，然后创建对象测试功能。

手机类

属性：品牌brand，价格price

行为：打电话call，发短信sendMessage，玩游戏playGame

成员方法对应的getXxx()和setXxx()方法

public class JavaObject {    //创建对象phone  
    public static void main(String [] args) {
        Phone p1 = new Phone();  //01，主方法声明p1，堆内存创建实体
        p1.setBrand("Apple");    //03进栈内存 赋值brand
        p1.setPrice(5288);  //05price

        System.out.println(p1.getBrand() + "..." + p1.getPrice());//09
    }
}

class Phone {
    private String brand;     //品牌   02null
    private int price;        //价格    0



    public void setBrand(String brand) {   //设置品牌04赋值
        this.brand = brand;
    }
    public String getBrand() {     //获取品牌07
        return brand;
    }


    public void setPrice(int price) {        //设置价格 06
        this.price = price;
    }
    public int getPrice() {            //获取价格08
        return price;
    }


    public void call() {
        System.out.println("打电话");
    }
    public void sendMessage() {
    System.out.println("发信息");
    }
    public void palyGame() {
    System.out.println("打游戏");
    }
}