Java基础知识笔记五（详细）

一 思想概述

1.1面向过程

1,因为面向对象思想是基于面向过程思想。回想一下之前，在做一些练习的时候，我首先得清楚，我需要做什么操作，然后在一步步分析要怎么做，最后用代码实现。需要面对每一个步骤和过程。
2,面向过程的代表语言：C语言

1.2面向对象

1,当需求单一或者简单时，我们一步一步的做是ok的，并且效率也挺高。但是随着需求的更改，功能的增多，发现需要面对每一个步骤就变得有些麻烦和繁琐了。所以我们要思索，能不能把这些步骤和功能在进行封装在一个类中，封装时根据不同的功能，进行不同的封装，同时功能类似的封装在一起。这就是面向对象思想。
2,面向对象的代表语言: Java语言

二 两者的区别

1,通过一个案例看看它们的区别。
在控制台打印的数组格式为:[元素1,元素2,元素3,元素4,元素5….]
面向过程思想做法

public static void main(String[] args) {
    //创建数组
    int[] arr = {1,2,3,4,5};
    //调用方法
    printArr(arr);
}
public static void printArr(int[] arr){
    System.out.print("[");
    for (int i = 0; i < arr.length; i++) {
        if(arr.length-1 == i){
            System.out.println(arr[i]+"]");
        }else{
            System.out.print(arr[i]+",");
        }
    }
}

面向对象思想做法

public static void main(String[] args) {
  	//创建数组
  	int[] arr = {1,2,3,4,5};
  	//调用方法
  	printArr(arr);
  }
public static void printArr(int[] arr){
    //借助了一个java中提供的对象
    System.out.println(Arrays.toString(arr));
}

2,总结：
面向过程强调的是每一个环节每一个步骤都需要自己去完成，比较复杂。
面向对象是根据Java中的一些类创建对象，让对象去帮我们调用方法完成，比较简单，
3,面向对象也有三个特征，即封装继承多态。

三 类与对象

1,什么是类
类是一组属性和行为的集合，我们可以当做是某一类事物的模板，从而使用该事物模板的属性和行为来描述这一类事物。
2,现实中如何描述一类事物
(1)属性:就是该事物的状态信息
(2)行为:就是该事物能够做什么
3,举例:鳄鱼
属性:名字，颜色，体重，年龄 行为:爬，吃，睡
4,什么是对象
对象是一类事物的具体体现。对象是类的一个实例，那么对象就必须具备该类事物的属性和行为。
5,现实中如何描述一个对象
举例:鳄鱼1号
属性:小黑，黑色，18kg，2岁 行为:慢慢爬，吃肉，睁眼睡
6,类与对象的关系
类是对一类事物的描述，是抽象的。
对象是一类事物的实例，是具体的。
类是对象的模板，对象是类的实体。

四 类的定义

1,现实世界的事物
(1)属性: 事物的描述信息
(2)行为: 事物能做什么
2.定义类其实就是定义类的成员
(1) 成员变量: 就是事物的属性
(2)成员方法: 就是事物的行为

五 类与对象的案例

1,学生类

public class Student {
   String name;//姓名
   int age;  //年龄
   public void study(){    //学习
       System.out.println("学生正在学习Java");
   }
    public void eat(){   //吃饭
        System.out.println("吃鸡腿");
    }
}

2,使用
创建对象：类名 对象名 = new 类名();
对象名.成员变量，对象名.成员方法

扫描二维码关注公众号，回复： 11318220 查看本文章

public class DemoStudent {
    public static void main(String[] args) {
        Student stu = new Student(); //创建学生类的对象
        System.out.println(stu);//地址值
        System.out.println("-----------------");
        //使用成员变量
        System.out.println("姓名:"+stu.name);//null
        System.out.println("年龄:"+stu.age);//0
        //给成员变量重新赋值
        stu.name = "小明";
        stu.age = 18;
        System.out.println("-----------------");
        //再次使用成员变量
        System.out.println("姓名:"+stu.name);//小明
        System.out.println("年龄:"+stu.age);//18
        //使用成员方法
        stu.study();
        stu.eat();
    }
}

六 对象内存图

public class Phone {
    String brand;
    double price;
    String color;
    public void call(String name){
        System.out.println("给"+name+"打电话");
    }
    public void send(){
        System.out.println("给小明发短信");
     }
}

1,一个对象的内存图

package com.baidu.demo;
public class DemoPhone {
    public static void main(String[] args) {
        Phone p = new Phone();
        System.out.println(p.brand);
        System.out.println(p.price);
        System.out.println(p.color);
        p.brand = "vivo";
        p.color = "黑色";
        p.price = 2299;
        System.out.println(p.brand);
        System.out.println(p.price);
        System.out.println(p.color);
        p.call("小明");
        p.send();
    }
}

一个对象的基本初始化过程

2,二个对象的内存图

package com.baidu.demo;
public class DemoPhone {
    public static void main(String[] args) {
        Phone p1 = new Phone();
        p1.brand = "华为";
        p1.price = 5000.0;
        p1.color = "金色";
        System.out.println("p1的品牌:"+p1.brand);
        System.out.println("p1的价格:"+p1.price);
        System.out.println("p1的颜色:"+p1.color);
        p1.call("李明");
        p1.send();
        System.out.println("=========");
        Phone p2 = new Phone();
        p2.brand = "魅族";
        p2.price = 6000.0;
        p2.color = "黑色";
        System.out.println("p2的品牌:"+p2.brand);
        System.out.println("p2的价格:"+p2.price);
        System.out.println("p2的颜色:"+p2.color);
        p2.call("小红");
        p2.send();
    }
}

方法的共用

3,二个对象的内存图

package com.baidu.demo;
public class DemoPhone {
    public static void main(String[] args) {
        Phone p1 = new Phone();
        p1.brand = "vivo";
        p1.price = 2299.0;
        p1.color = "黑色";
        System.out.println("p1的品牌:"+p1.brand);
        System.out.println("p1的价格:"+p1.price);
        System.out.println("p1的颜色:"+p1.color);
        Phone p2 = p1;
        p2.brand = "VIVO";
        p2.price = 1799.0;
        p2.color = "白色";
        System.out.println("p2的品牌:"+p2.brand);
        System.out.println("p2的价格:"+p2.price);
        System.out.println("p2的颜色:"+p2.color);
        System.out.println("p1的品牌:"+p1.brand);
        System.out.println("p1的价格:"+p1.price);
        System.out.println("p1的颜色:"+p1.color);
    }
}

两个引用指向同一个对象

七 成员变量和局部变量的区别

1,在类中的位置不同
成员变量:类中方法外.
部变量:方法内或者方法声明上
2,在内存中的位置不同
成员变量:堆内存
局部变量;栈内存
3,生命周期不同
成员变量:随着对象的存在而存在，随着对象的消失而消失
局部变量:随着方法的调用而存在，随着方法的调用完毕而消失
4,初始化值不同
成员变量:有默认的初始化值
局部变量:没有默认的初始化值，必须先定义，赋值，才能使用。

八 private关键字

1,private关键字：是一个权限修饰符。可以修饰成员(成员变量和成员方法)
被private修饰的成员只在本类中才能访问。
2.private最常见的应用：把成员变量用private修饰，
提供对应的getXxx()/setXxx()方法
3,案例的使用
通过对象访问成员变量，会存在数据不安全的问题。
我们应该想想能不能让用户对象其赋值的时候有一些限制。
private关键字，实现限定
private：是一个修饰符，可以修饰成员变量，也可以修饰成员方法 如果成员变量或成员 方法被private修饰，那么只能在本类中访问 针对private修饰的成员变量，外界如果想要访问，我们必须在类中提供对应getXxx() setXxx()一组方法，方法必须是public

public class Student {
    private String name;
    private int age;
    public void show(){
        System.out.println("姓名是:"+name+"年龄是:"+age);
        //eat();
    }
    /* private void eat(){
        System.out.println("吃肉肉..");
    }*/
    public void setName(String n){
        name = n;
    }
    public String getName(){
        return name;
    }
    public void setAge(int a){
        if(a > 100 || a < 0){
            System.out.println("年龄不合法!!!");
        }else{
            age = a;
        }
    }
    public int getAge(){
        return age;
    }
}

学生的测试类

public class DemoStudent {
    public static void main(String[] args) {
        //创建学生对象
        Student stu = new Student();
        stu.show();
        //对成员变量进行赋值
        stu.setName("小明");
        stu.setAge(18);
        stu.show();
        //也可以单独使用get方法获取成员变量的值
        System.out.println(stu.getName());
    }
}