黑马程序员--java基础之类与对象

——- android培训、java培训、期待与您交流！ ———-

面向对象：就是以对象为视角来看待世界或者来阐述的一种思维方式。
面向过程：强调的是过程、强调的是方法
面向对象：强调的是拥有这个方法的对象。

    鸡蛋灌饼：
        面向过程：
            1.学习鸡蛋灌饼的制作方法
            2.麦面、鸡蛋、油、设备
            3.和面、制作鸡蛋灌饼
            4.吃
        面向对象：
            1.找一个卖鸡蛋灌饼的大妈
            2.给人家钱
            3.吃
    洗衣服：
        面向过程：
            1.买个洗衣机
            2.买洗衣粉
            3.加水、加洗衣服、把衣服放进去
            4.打开洗衣机，设置时间
            5.晾衣服
            6.收衣服
        面向对象：
            1.找一个会洗衣服的对象

/**
*
*   自定义一个 汽车类
*/
class Car {
    //属性：
    //品牌，价格
    //品牌
    String brand;
    //价格
    double price;

    //方法
    //跑的方法
    public void run(){
        System.out.println("哎呦，我怎么跑这快……");
    }
}


//汽车测试类
class CarTest {
    public static void main(String[] args){
        /*
        //创建一个汽车对象
        Car c = new Car();
        //给c的品牌赋值
        c.brand = "劳斯莱斯幻影"; 
        System.out.println(c.brand);
        System.out.println(c.price);


        //创建一个汽车对象‘
        Car c1 = new Car();
        //让这辆车的品牌是“奔驰”
        c1.brand = "奔驰";

        //创建第二辆汽车
        Car c2 = new Car();
        //第二辆车的价格是“40”
        c2.price = 40;

        System.out.println(c1.price);
        System.out.println(c2.brand);

        */


        //创建一个汽车对象
        Car c1 = new Car(); 
        Car c2 = c1;
        c2.brand = "宝马";
        //c1.brand;
        System.out.println(c1.brand);
    }
}

面向对象的特点：
1.把事物简单化
2.更加符合人们的思维习惯
3.把我们从执行者转换为指挥者

面向过程：
    1.冰箱打开()
    2.大象进去()
    3.冰箱关闭()
面向对象：
    1.冰箱把门打开
    2.指挥大象进入冰箱

在方法中的变量称之为：局部变量
在方法之外，类之中的变量：成员变量

属性：就是放在类之中方法之外的变量。
方法：
        今天我们所有的方法（除了main方法），都不写static

//定义一个美女类
class Beauty {
    //属性（成员变量）
    //姓名
    String name;
    //年龄
    int age;
    //性别
    String sex;

    //方法
    //撒娇、卖萌
    //撒娇
    public void coquetry(){
        System.out.println("哎呀，讨厌……");
    }
    //卖萌
    public void cute(){
        System.out.println("么么哒");
    }
}

测试类：一般用来测试别的类的类叫做测试类。测试类一般包含main方法

操作类，必须现有类的对象才能操作。操作类本质上操作的是类的对象。
创建对象：
    格式：
        类 对象名 = new 类名();
        类 对象名:叫做对象的声明。对象的引用。
        new 类名();这一部分才是真正的创建对象。

class BeautyTest {
    public static void main(String[] args) {
        //创建一个美女对象
        Beauty bea = new Beauty();

        //对对象进行操作
        //bea
        //操作方法
        bea.coquetry();  //让bea这个美女，执行撒娇方法。
        //美女去卖萌
        bea.cute();

        //属性的使用
        //使用名字
        System.out.println(bea.name);
        //使用年龄
        System.out.println(bea.age);
        //改名字
        bea.name = "如花";

        System.out.println(bea.name);
    }
}

成员变量和局部变量的区别:
    所在位置：
        成员变量：方法外部、类的内部。
        局部变量：方法内部。
    使用范围：
        成员变量：在类的内部任何地方都可以被访问。
        局部变量：只能在他所在的方法中访问。
    默认值：
        成员变量：有默认值
        局部变量：没有默认值
    所在位置：
        成员变量：在堆中存储，和对象放在一块。
        局部变量：存储在栈中。
    生命周期：
        成员变量：随着对象的创建而创建，随着对象的消失而消失。  //对象变量
        局部变量：随着方法的调用而创建，随着方法的消失而消失。

class ChengYuanBianLiang {

    //定义一个int类型的变量
    int a;

    public void test(){
        int b;
        System.out.println(b);
    }

    public void show(){
        System.out.println(a);  
    }


}

class ChengYuanBianLiangTest {
    //主方法
    public static void main(String[] args){
        //创建对象
        ChengYuanBianLiang cybl = new ChengYuanBianLiang();
        //System.out.println(cybl.a);   
        cybl.show();
    }
}

构造方法：
    格式：
        访问修饰符 类名(){
        }

        注意：
            1.不能有返回值类型。
            2.方法名和类名完全相同

    构造方法注意事项：
        1.当我们的类中不写构造方法时，系统会默认给我们添加一个无参构造方法。
        2.构造方法也可以实现方法重载。也就是说构造方法也可以有多个。
        3.构造方法在创建对象时调用。
        4.构造方法不允许手动调用，只能在创建对象时由Java虚拟机自动调用。
        5.当我们写了构造方法之后，系统就不再默认给我们添加无参构造方法了。


    构造方法的作用：一般用来对属性进行赋值（初始化）


普通方法完整格式：
    访问修饰符 返回值类型 方法名(参数列表)｛
        方法体
        return 值
    ｝

class PersonTest {
    public static void main(String[] args) {
        //创建一个对象
        //Person p = new Person();
        //调用方法
        //p.say();
        Person p1 = new Person("你好世界");
        System.out.println(p1.name);


    }
}

//自定义一个人类。
class Person {

    String name;

    public void say(){
        System.out.println("你好");
    }

    /*
    public Person(){
        System.out.println("无参构造方法");
    }
    */

    public Person(String s){
        //System.out.println("有参构造方法");

        name = s;
    }


}

private：私有的。可以修饰属性，可以修饰方法。
被private修饰的属性或方法在类的外部都不能被访问。

封装：把我们不想让别人看到或用到的东西加以限制，不让别人随意使用，这种思想就是封装。
    封装的体现：
        1.属性私有化。
        2.方法也是封装。
    封装的好处：
        1.提高了代码的安全性。
        2.提高了代码的复用性，可维护性。
        3.隐藏了实现细节。

class PersonTest1 {
    public static void main(String[] args) {
        //创建一个人的对象
        Person p = new Person("张曼玉");

        //System.out.println(p.name);

        //p.name = "张妞妞";

        //System.out.println(p.name);

        //p.say();


    }
}

//自定义一个人类。
class Person {  

    private String name;

    public void say(){
        System.out.println("你好");
    }

    public Person(String s){
        name = s;
    }
}

使用封装的思想写一个学生类。
    潜规则：
        对于设置属性的方法，一般都叫做：“set属性名()”
        对于获取属性的方法，一般都叫做: “get属性名()”

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

    //写一个用来改名字的方法
    public void setName(String s){
        /*
            if(s 很难听)｛
                我就不允许你給我改名字
            ｝
        */
        name = s;
    }


    //定义一个获取名字的方法
    public String getName(){
        return name;
    }


    //设置年龄的方法
    public void setAge(int i){
        age = i;
    }

    //获取年龄的方法
    public int getAge(){
        return age;
    }



    //方法，study方法
    public void study(){
        System.out.println("学习方法");
    }
}

class StudentDemo {
    public static void main(String[] args){
        //创建一个学生对象
        Student s = new Student();
        //该这个人的名字
        s.setName("张妞妞");

        //String str = s.getName();
        //System.out.println(str);
        System.out.println(s.getName());
    }
}

一个Java文件中可以有多个类。文件名必须和main方法所在的类的类名保持一致。

类名 如花 = new 类名();
调用：
    调用属性：如花.name;
    调用方法：如花.study();

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


    //方法。
    //学习、吃饭
    //学习
    public void study(){
        System.out.println("正在上课");
    }
    //吃饭
    public void eat(){
        System.out.println("一会再去吃饭");
    }
}

//写一个学生的测试类
class StudentTest {
    public static void main(String[] args){
        //创建学生对象
        Student s = new Student();

        //调用学生的学习方法
        s.study();
        //调用学生的姓名属性
        System.out.println(s.name);
    }
}

标准版的教师类：
    Java中的标准类:
        属性、方法
        属性必须都封装
        构造方法必须有2个，一个无参，一个有参

class Teacher {
    //属性
    //姓名
    private String name;
    //年龄
    private int age;

    //构造方法
    //无参构造
    public Teacher(){}
    //有参构造方法
    public Teacher(String n,int a){
        name = n;
        age = a;
    }

    //设置名字的方法
    public void setName(String n){
        name = n;
    }
    //获取名字的方法
    public String getName(){
        return name;
    }

    //设置年龄的方法
    public void setAge(int a){
        age = a;
    }

    //获取年龄的方法
    public int getAge(){
        return age;
    }


    //方法
    //教学方法
    public void teach(){
        System.out.println("上课");
    }
}

匿名对象：就是没有名字的对象
    匿名对象可以调用方法，也可以调用属性。

    匿名对象只能使用一次。

class NiMingDemo {
    public static void main(String[] args) {
        //创建一个汽车对象;
        //Car c = new Car();
        //c.run();
        //匿名对象调用方法
        //new Car().run();
        //匿名对象调用属性
        //System.out.println(new Car().price);

        new Car().brand = "奥拓";
        new Car().price = 10;
        System.out.println(new Car().brand);

    }
}

class Car {
    //品牌
    String brand;
    //价格
    int price;

    //run方法
    public void run(){
        System.out.println("汽车在跑");
    }
}

咱们自定义的类，也是数据类型，也可以作为参数。
匿名对象的应用场景:
    1.可以作为参数进行传递
    2.当我们只是使用一次时，我们就可以使用匿名对象。

class NiMingDemo2 {
    public static void main(String[] args) {
        //创建一个Car对象
        Car c = new Car();
        //把c作为参数进行传递
        test(c);

        /*
        Car c1 = new Car();
        test(c1);

        Car c2 = new Car();
        test(c2);

        Car c3 = new Car();
        test(c3);


        test(new Car());

        test(new Car());

        test(new Car());


        Car c1 = new Car();
        c1.run();
        */

         new Car().run();

    }

    public static void test(Car c){
        //只要进入这个方法，S这辆车就必须有了
        c.run();

        //打印一下c的品牌
        System.out.println(c.brand);
    }
}


class Car {
    //品牌
    String brand;
    //价格
    int price;

    //run方法
    public void run(){
        System.out.println("汽车在跑");
    }
}

总结

    构造方法和普通方法的区别：
方法名：
    构造方法：方法名必须和类名保持一致。
    普通方法：见名知意
    返回值：
    构造方法：没有返回值。连void 都没有
    普通方法：正常的返回值
方法调用：
    构造方法：我们自己不能调用，只能在创建对象时，由Java虚拟机来调用。
    普通方法：方法名(参数列表);
方法体：
    构造方法：可以写任何东西，但是一般用来给属性赋值（初始化）
    普通方法：任何代码都可以。

构造方法：
    如果我们一个都不写，则系统会给我们添加一个默认的。
    如果我们写了，不管写的是什么构造方法，系统就不再给我们添加默认的构造方法了。

面向对象概述：
面向对象指的就是，以对象为视角来阐述世界的思维方式。
OO：指的就是面向对象
OOP：面向对象编程
对象：
万物皆对象。

面向对象特点：
1.把事物简单化
2.更加符合人的思维习惯。
3.把我们从执行者变成指挥者。

面向对象三大特征：封装、继承、多态。

类的定义：
主要定义类的属性和方法。
    属性必须放在方法之外，类之内。
    方法：今天的方法没有static，其他和普通方法一样。

对象的创建和使用：
创建对象格式：
    类名 对象名 = new 类名();
        类名 对象名:叫做对象的声明也叫对象的引用。
        new 类名();才是真正的对象。
对象的使用：
    1.使用属性：
        对象名.属性;
    2.使用方法：
        对象名.方法();

成员变量和局部变量：
定义位置：
    成员变量：在方法之外，类之内
    局部变量：在方法内部。
使用范围：
    成员变量：在整个类中都可以访问。
    局部变量：只能在局部变量所在的方法内部访问。
默认值：
    成员变量：有默认值
    局部变量：没有默认值
生命周期：
    成员变量：随着对象的创建而创建，随着对象的消失而消失。
    局部变量：随着方法的调用而出现，随着方法的结束而消失。
存储位置：
    成员变量：在堆中，和对象在一块
    局部变量：在栈中。


匿名对象：就是没有名字的对象。
注意：“
    1.匿名对象只能使用一次。
    2.匿名对象可以作为参数传递。

构造函数：
1.方法名必须和类名保持一致。
2.构造方法没有返回值。连void都没有
3.如果我们自己不写构造方法，则系统会自动给我们添加一个默认的无参构造方法。
    如果我们写了任何构造方法，系统不再给我们提供默认的构造方法了。
4.构造方法一般用来对属性进行初始化。
5.构造方法不能手动调用，只能在创建对象时，由JVM自动调用。

private(私有)关键字：
可以修饰方法，可以修饰属性
当priavte修饰方法或属性时，属性和方法都不能在类的外部被访问。
封装：
对我们不想让被人知道或者用到的东西加以限制，限制别人的访问，这种思想就是封装。
    属性的私有化就是一种封装。
    方法也是一种封装。

属性封装：
1.把属性私有化。
2.给每个属性都提供两个方法。
    一个用来获取属性的值："get属性名()"
    一个用来设置属性的值："set属性名()"

——- android培训、java培训、期待与您交流！ ———-