java基础————面向对象

----------- android培训、java培训、java学习型技术博客、期待与您交流！------------

 

 

面向对象的引入---->>

    当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。
    可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了，这时
    就开始思索，能不能把这些步骤和功能在进行封装，封装时根据不同的功能，
    进行不同的封装，功能类似的封装在一起。这样结构就清晰了很多。用的时候，
    找到对应的类就可以了。

面向对象的思想---->>
        
        面向过程:    关注的是步骤和过程
        面向对象:    关注的是对象
                    面向对象是基于面向过程的
                    指挥对象做事情 , 创建对象调用方法

 类与对象及其应用---->>
        
        事物                   类
            属性                成员变量
            行为                成员方法
        
        属性:    就是事物的描述信息
        行为:    就是这个事物可以做什么事情

        成员变量:    和之前定义变量一样 , 只不过位置不同 , 在类中方法外
        成员方法:    和之前定义方法一样 , 只不过去掉static

        类:        是一组相关属性和行为的集合 , 是一个抽象的东西
        对象:    就是该类的一个具体的体现
        举例:
                学生            类
                班长            对象

        类的定义:    定义该的成员变量和成员方法

下面我们来定义一个学生类

//这是我的学生类
class Student {
    //定义变量
    //姓名
    String name;
    //年龄
    int age;
    //地址
    String address;
    
    //定义方法
    //学习的方法
    public void study() {
        System.out.println("学生爱学习");
    }
    
    //吃饭的方法
    public void eat() {
        System.out.println("学习饿了,要吃饭");
    }
    
    //睡觉的方法
    public void sleep() {
        System.out.println("学习累了,要睡觉");
    }
}

 

 

 

类的使用:---->>
        类是一个抽象的东西, 我们就不能直接使用, 如果我们想使用这个类,我们需要使用该类的一个具体的体现(对象)
        如何获取某一个类的对象呢?
            格式:    类名 对象名 = new 类名() ;
        如何使用这个对象的成员变量?
            格式:    对象名.变量名 ;
        如何使用这个对象的成员方法?
            格式:    对象名.方法名(...) ;
如：学生类是一个抽象的概念，没什么意义。我们通过 new 就可以得到他的具体对象
    这样我们就得到了张峰这个具体的对象了

 

 

 

 

class  StudentTest{

    public static void main(String[] args){

        //创建对象
        Student s = new Student();
        

        //对成员变量赋值
        s.name = "张峰";
        s.age = 18;
        s.address = "北京"

        System.out.println("姓名是:" + s.name);
        System.out.println("年龄是:" + s.age);
        System.out.println("家住:" + s.address);
        
        //调用方法
        s.eat();
        s.study();
        s.sleep();

    }
}

对象的内存分布--->>
        
        java语言的内存分配
            a: 栈:    存储的都是局部变量
                    局部变量: 就是在方法定义中或者方法声明上的变量
            b: 堆:  存储的都是new出来的东西
                    (1): 每一个new出来的东西系统都会为其分配一个地址值
                    (2): 每一个元素系统都会为其分配默认的初始化值
                         byte , short , int , long     ---- 0
                         float , double                 ---- 0.0
                         char                         ---- '\u0000'
                         boolean                     ---- false
                         引用数据类型                 ---- null
                    (3): 使用完毕以后就变成的垃圾,等待垃圾回收器对其回收

            c: 方法区(面向对象部分研究)
            d: 本地方法区(和系统相关)
            e: 寄存器(CPU)


成员变量和局部变量的区别--->>
            
        (1): 在类中的位置不同
             成员变量: 在类中方法外
             局部变量: 在方法定义中或者方法声明上
        (2): 在内存中的位置不同
             成员变量:    在堆内存中
             局部变量:  在栈内存中
        (3): 生命周期的不同:
             成员变量:    随着对象的创建而产生,随着对象的消失而消失
             局部变量:    随着方法的调用而产生 , 随着方法的消失而消失
        (4): 默认值的问题:
             成员变量:    有默认的初始化值
             局部变量:    没有默认的初始化值 , 使用之前,必须对其赋值
匿名对象---->>
       
       概述: 就是没有名字的对象
       举例:    new Student() ;
       作用:
            a.调用方法 , 当我们调用方法时,这个方法仅仅是调用一次的时候
            b.作为参数传递
            
       调用方法的格式:
                new Student().show();

举例：厨师叫服务员端菜。
    这个案例中厨师叫服务员端菜，并没有指定那个服务员，而且只需要端一次。
    所以我们可以使用匿名对象

 

 

 

class  CookTest{

    public static void main(String[] args){

        //创建厨师对象

        Cook c = new Cook();

        c.make();

        //创建服务员对象
        Waiter cuiHua = new Waiter();
        //如果你的参数是一个类名,实际传递的应该是类的对象
        //c.call(cuiHua);

        c.call(new Waiter());
        

    }
}
//厨师类
class Cook{
    //成员方法
    //做菜
    public void make(){
        System.out.println("厨师能做菜");    
    }

    //叫服务员
    public void call(Waiter waiter){
        waiter.duanCai();
    }

}

//服务员类
class Waiter{

    public void duanCai(){
        System.out.println("狗肉汤来了!~~~~~~");
    }
}

 

    
封装(private):
        
            private: 表示的意思的私有的

            private的特点:
                (1): private 是一个修饰符
                (2): private 可以修饰成员变量和成员方法
                (3): 被private修饰的的成员只能在本类中方法

            private 最常见的应用场景:    
                把成员变量使用private修饰,然后提供对象的get和set方法


 this关键字 :
        
        使用场景:    当我们的局部变量隐藏了成员变量的时候,我们可以使用this关键字,来明确我们访问的是成员变量

        this: 表示的是本类对象的一个引用 , 谁调用我方法中的this就代表谁

java语言的参数传递问题:
        
        基本数据类型的参数传递,形式参数的改变对实际参数没有影响
        引用数据类型的参数传递,形式参数的改变对实际参数的是有直接影响的

        虽然String是引用数据类型,但是在传递的时候是按照基本数据类型的特点进行传递的,传递其实是具体的字符串对应的值

        类名在作为参数的时候我们如何调用?
        
        如果以后看到一个方法上需要一个类类型的变量, 那么我们在调用的使用,其实我们需要给其传递一个该类的对象

        public void show(Student s) {                    // 在调用这个方法的时候,需要传递一个Student类的对象
            System.out.println("show.......") ;
        }



        
    构造方法------->>
        特点:    
            (1): 方法名和类名相同
            (2): 没有返回值类型 , 连void也没有
            (3): 没有具体的返回值

        作用:
            对类的成员变量初始化
        注意事项:
            (1): 如果我们没有给出构造方法,系统将会提供一个默认的无参的构造方法
            (2): 如果我们给出构造方法 , 系统将不会在通过默认的无参的构造方法
                 这个时候如果我们还想使用无参的构造方法,那么这个时候我们需要自己给出(建议: 都是自己给出)
    对象的创建步骤
        
        Student s = new Student() ;
        
        (1): 加载Student的字节码文件到方法区
        (2): 在栈内存中为s开辟空间
        (3): 在堆内存中为new Student()开辟空间
        (4): 给Student的成员变量进行默认初始化
        (5): 给Student的成员变量进行显式初始化
        (6): 通过构造方法对成员变量进行初始化
        (7): 把堆内存中产生的地址值赋值给栈内存中的应用变量s

        举例:

 

 

 

 

 

 

class Student {
    
        //成员变量
        private String name;
        private int age;
        private String studyNum;
            
        //构造方法
            //无参
            Student(){}
            //有参
            Student(String name, int age,String studyNum){
                this.name = name;
                this.age =age;
                this.studyNum = studyNum;
            }
        //成员方法
            //get /set

            public String getName(){
                return name;        
            }
            public void setName(String name){
                this.name = name;
            }

            public int getAge(){
                return age;        
            }
            public void setAge(int age){
                this.age = age;
            }


            public String getStudyNum(){
                return studyNum;        
            }
            public void setStudyNum(String studyNum){
                this.studyNum = studyNum;
            }

            //特有方法

            public void study(){
                System.out.println("好好学习");
            }

            public void eat(String food){
                System.out.println(name + "同学爱吃" + food);
            }

            public void sleep(){
                System.out.println("好好睡觉~~~");
            }
    }

 

 

    static关键字:

        static 的意思是静态的
        特点:
            a: 随着类的加载而加载
            b: 优先于对象存在
            c: 被类的所有的对象所共享
            d: 可以通过类名调用,其本身也可以通过对象名调用
                建议使用类名调用

        注意事项:
            静态只能访问静态 , 非静态可以访问静态也可以访问非静态
    

    代码块
        概述:    在java语言中使用{}括起来的内容
        分类:    
                局部代码块 , 构造代码块 , 静态代码块 , 同步代码块(多线程在讲解)
        
        局部代码块:    在局部位置        作用: 用来限定变量的生命周期,提早释放内存,提高内存的使用率
        构造代码块: 在类中方法外    作用: 我们可以将多个构造方法都要执行的代码方法构造代码块中
                    特点:    每一次创建对象的时候都要执行 , 并且它的执行优先于构造方法
        静态代码块:
                    在类中方法外 , 前面需要添加一个static关键字
                    作用:
                        可以对类进行初始化 , 如果我们现在加载这个类的时候做一些事情
                    特点:    随着类的加载而执行 , 并且是执行一次 , 优先于构造代码块执行