javase基础7

1.面向过程和面向对象思想

面向过程:其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。
面向对象:面向对象思想就是不断的创建对象，使用对象，指挥对象做事情。

面向过程的特点:强调的是过程，所有事情都需要自己完成
面向对象:是一种更符合我们思想习惯的思想(懒人思想),可以将复杂的事情简单化

2.类与对象

A:我们学习编程是为了什么
为了把我们日常生活中实物用学习语言描述出来
B:我们如何描述现实世界事物
属性 就是该事物的描述信息(事物身上的名词)
行为 就是该事物能够做什么(事物身上的动词)
C:Java中最基本的单位是类,Java中用class描述事物也是如此
成员变量 就是事物的属性
成员方法 就是事物的行为
D:定义类其实就是定义类的成员(成员变量和成员方法)
a:成员变量 和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。
b:成员方法 和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。
E:类和对象的概念
a:类：是一组相关的属性和行为的集合（我们班所有的同学都具备相同的属性和行为，比如：姓名，年龄，学习，这样就把所有的学生成为学生类）
b:对象：是该类事物的具体体现（说某个同学时，他都具备自己特有的属性和行为）
c:举例：
类 学生
对象 具体的某个学生就是一个对象
比如：车是一个类，具体的开的奔驰、宝马，就是对象

/*
 * 类的定义：
 *         类是用来描述现实世界的事物的
 * 
 * 事物：
 *         属性    事物的描述信息
 *         行为    事物能够做什么
 * 
 * 类是如何和事物进行对应的呢?
 *         类：
 *             成员变量
 *             成员方法
 * 
 * 需求：写一个学生类
 * 
 * 学生事物：
 *         属性：姓名，年龄...
 *         行为：学习，吃饭...
 * 
 * 学生类：
 *         成员变量：姓名,年龄
 *         成员方法：学习,吃饭
 *
 * 成员变量：和我们前面学习过的变量的定义是一样的。
 *         位置不同：类中，方法外
 *         初始化值：不需要给初始化值
 * 成员方法：和我们前面学习过的方法的定义是一样的。
 *         去掉static关键字
 */
public class Student {
    //成员变量
    //姓名
    String name;
    //年龄
    int age;
    
    //成员方法
    //学习的方法
    public void study() {
        System.out.println("好好学习，天天向上");
    }
    
    //吃饭的方法
    public void eat() {
        System.out.println("学习饿了要吃饭");
    }
}

/*
 * Student是一个学生事物描述类，main方法不适合放在它里面。
 * 
 * 使用一个类，其实就是使用该类的成员。(成员变量和成员方法)
 * 而我们要想使用一个类的成员，就必须首先拥有该类的对象。
 * 我们如何拥有一个类的对象呢?
 *         创建对象就可以了?
 * 我们如何创建对象呢?
 *         格式：类名 对象名 = new 类名();
 * 对象如何访问成员呢?
 *         成员变量：对象名.变量名
 *         成员方法：对象名.方法名(...)
 */
public class StudentDemo {
    public static void main(String[] args) {
        //格式：类名 对象名 = new 类名();
        Student s = new Student();
        //System.out.println("s:"+s);
        
        //直接输出成员变量值
        System.out.println("姓名："+s.name); //null
        System.out.println("年龄："+s.age); //0
        System.out.println("----------");
        
        //给成员变量赋值
        s.name = "张三";
        s.age = 23;
        
        //再次输出成员变量的值
        System.out.println("姓名："+s.name); 
        System.out.println("年龄："+s.age); 
        System.out.println("----------");
        
        //调用成员方法
        s.study();
        s.eat();
    }
}

3.成员变量和局部变量的区别

/*
 * 成员变量和局部变量的区别：
 *         A:在类中的位置不同
 *             成员变量：类中，方法外
 *             局部变量：方法中或者方法声明上(形式参数)
 *         B:在内存中的位置不同
 *             成员变量：堆内存
 *             局部变量：栈内存
 *         C:生命周期不同
 *             成员变量：随着对象的创建而存在，随着对象的消失而消失
 *             局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
 *         D:初始化值的问题
 *             成员变量：有默认值
 *             局部变量：没有默认值。必须先定义，赋值，最后使用
 */
public class Variable {
    int x;
    public void show() {
        int y = 0;

        System.out.println(x);
        System.out.println(y);
    }
}

4.private关键字

是一个权限修饰符
可以修饰成员(成员变量和成员方法)

/*
 * 学生类
 * 
 * 通过对象直接访问成员变量，会存在数据安全问题
 * 这个时候，我们就想能不能不让外界的对象直接访问成员变量呢?
 * 能。
 * 如何实现呢?
 *         private关键字
 * 
 * private:
 *         是一个修饰符
 *         可以修饰成员变量，也可以修饰成员方法
 *         被private修饰的成员只能在本类中被访问
 * 
 * 针对private修饰的成员变量，我们会相应的提供getXxx()和setXxx()用于获取和设置成员变量的值,方法用public修饰
 */
public class Student {
    String name;
    //int age;
    private int age;
    
    public void setAge(int a) {
        if(a<0 || a>200) {
            System.out.println("你给的年龄有误");
        }else {
            age = a;
        }
    }
    
    public int getAge() {
        return age;
    }
    
    public void show() {
        System.out.println("姓名是："+name+",年龄是："+age);
    }
}

/*
 * 学生类的测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建学生对象
        Student s = new Student();
        s.show();
        
        s.name = "林青霞";
        //s.age = 28;
        //s.age = -28;
        //s.setAge(-28);
        s.setAge(28);
        s.show();
    }
}

注意:

A:把成员变量用private修饰
B:提供对应的getXxx()/setXxx()方法

/*
 * 学生类
 */
public class Student {
    private String name;
    private int age;
    
    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 class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        System.out.println(s.getName()+"---"+s.getAge());
        
        s.setName("张三");
        s.setAge(23);
        System.out.println(s.getName()+"---"+s.getAge());
    }
}

5.封装

封装的概述:
是面向对象三大特征之一
是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。就像刚才说的年龄。

封装的原则:
将不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共方法对其访问。
成员变量private，提供对应的getXxx()/setXxx()方法

好处:
通过方法来控制成员变量的操作，提高了代码的安全性
把代码用方法进行封装，提高了代码的复用性

6.this关键字

A:this:代表所在类的对象引用
方法被哪个对象调用，this就代表那个对象
B:什么时候使用this呢
局部变量和成员变量重名

7.构造方法

主要用来给对象的数据进行初始化

构造方法格式:
a:方法名与类名相同
b:没有返回值类型，连void都没有
c:没有具体的返回值

public class Student {    
    public Student() {
        System.out.println("这是构造方法");
    }
}

如果你不提供构造方法，系统会给出默认构造方法
如果你提供了构造方法，系统将不再提供
构造方法也是可以重载的,重载条件和普通方法相同