Java基础笔记（3）类与对象、部分常用关键字

一、面向对象

    1.面向对象是一种编程思想，把复杂的事情简单化，比起面向过程更符合我们的思考习惯。
    2.类与对象
        1)现实世界的事物
            属性：事物的基本描述
            行为：事物的功能
        2)Java语言中最基本的单位是类。所以，我们要用类来体现事物
        3)类
            成员变量：事物属性
            成员方法：事物行为
        4)类：是一组相关的属性和行为的集合，是一个抽象的概念。
          对象：是该类事物的具体存在，是一个具体的实例。
          
          举例：
            学生：类
            班长：对象
        5)类的定义及使用
            A:类的定义
                成员变量：在类中，方法外。
                成员方法：在类中，在方法名后面接“()”
            B:使用类的内容
                a:创建对象的格式
                    类名 对象名 =  new 类名();
                b:如何使用成员变量和成员方法呢
                    对象名.成员变量
                    对象名.成员方法()
        6)Java程序的开发，设计和特征
            A:开发：就是不断的创建对象，通过对象调用功能
            B:设计：就是管理和维护对象间的关系
            C:特征
                a:封装
                b:继承
                c:多态
    3.注意：如何让我们的操作更符合面向对象思想呢?
        1)有哪些类
        2)每个类有哪些成员
        3)类与类的关系

二、类的详解

    1.成员变量和局部变量的区别
        1)在类中的位置不同
            成员变量：类中方法外
            局部变量：方法定义中或者方法声明上
        2)在内存中的位置不同
            成员变量：在堆中
            局部变量：在栈中
        3)生命周期不同
            成员变量：随着对象的创建而存在，随着对象的消失而消失
            局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
        4)初始化值不同
            成员变量：有默认值
            局部变量：没有默认值，必须定义，赋值，然后才能使用
    2.封装
        1)隐藏实现细节，提供公共的访问方式
        2)好处：
            A:隐藏实现细节，提供公共的访问方式
            B:提高代码的复用性
            C:提高代码的安全性
        3)设计原则
            把不想让外界知道的实现细节给隐藏起来，提供公共的访问方式
        4)private是封装的一种体现，在封装的设计中常用来修饰成员变量。
            封装：类，方法。
    3.构造方法
        1)作用：用于对对象的数据进行初始化
        2)格式：
            A:方法名和类名相同
            B:没有返回值类型，连void都不能有
            C:没有返回值
            如：

public class User{
    private String username;
    private String password;
            
    //无参构造方法
    public User(){
        //super();//父类的构造方法，用于初始化父类成员变量。系统默认加上
    }
                    
    //带参构造方法
    public User(String username, String password){
        this.username = username;
        this.password = password;
    }
                    
    //... 省略get和set方法
}

            思考题：构造方法中可不可以有return语句呢?
            可以。而是我们写成这个样子就OK了：return;
            其实，在任何的void类型的方法的最后你都可以写上：return;
        3)构造方法的注意事项
            A:如果我们没写构造方法，系统将提供一个默认的无参构造方法
            B:如果我们给出了构造方法，系统将不再提供默认构造方法
                如果这个时候，我们要使用无参构造方法，就必须自己给出。
                推荐：永远手动自己给出无参构造方法。
        4)给成员变量赋值的方式
            A:setXxx()
            B:带参构造方法
    4.匿名对象
        1)没有名字的对象
        2)应用场景
            A:调用方法，仅仅只调用一次的时候。
            B:可以作为实际参数传递。
    5.代码：Student s = new Student();做了哪些事情？
        1)把Student.class文件加载到内存
        2)在栈内存为s开辟空间
        3)在堆内存为学生对象申请空间
        4)给学生的成员变量进行默认初始化。（null、0、false等。）
        5)给学生的成员变量进行显示初始化。
        6)通过构造方法给成员变量进行初始化。
        7)对象构造完毕，把地址赋值给s变量

三、关键字

    1.private关键字
        1)私有的意义，可以修饰成员变量和成员方法
        2)特点：被private修饰的后的成员只能在本类中被访问
        3)private的应用：
            创建一个简单类的时候：
                A:把所有的成员变量给private了
                B:提供对应的getXxx()/setXxx()方法
    2.this关键字
        1)代表当前类的引用对象
            注意：
                A:哪个对象调用方法，该方法内部的this就代表那个对象
                B:不能放在static修饰的方法中
        2)this的应用场景：
            A:引用局部变量 —— 解决了局部变量隐藏成员变量的问题
            B:引用成员方法
            C:在构造方法内引用其它构造方法
    3.super关键字
        1)待办当前类的父类引用对象。注意事项同this。
        2)super的应用场景
            A:引用成员方法（尤其是子类重写了该方法时，要用父类的该方法，就可以用super.方法名()）
            B:在子类构造方法内首行默认添加，用于初始化父类的成员变量。
    4.static关键字
        1)可以修饰成员变量和成员方法，修饰后成为类变量和类方法。
        2)静态的特点：
            A:随着类的加载而加载
            B:优先于对象存在
            C:被类的所有对象共享
                这其实也是我们判断该不该使用静态的依据。
            D:可以通过类名调用
                既可以通过对象名调用，也可以通过类名调用，建议通过类名调用。
        3)静态的内存图
            静态的内容在方法区的静态区

        4)静态的注意事项；
            A:在静态方法中没有this对象
            B:静态只能访问静态
        5)静态变量和成员变量的区别
            A:所属不同
                静态变量：属于类，类变量
                成员变量：属于对象，对象变量，实例变量
            B:内存位置不同
                静态变量：方法区的静态区
                成员变量：堆内存
            C:生命周期不同
                静态变量：静态变量是随着类的加载而加载，随着类的消失而消失
                成员变量：成员变量是随着对象的创建而存在，随着对象的消失而消失
            D:调用不同
                静态变量：可以通过对象名调用，也可以通过类名调用
                成员变量：只能通过对象名调用
        6)main方法是静态的
            public:权限最大
            static:不用创建对象调用
            void:返回值给jvm没有意义
            main:就是一个常见的名称。
            String[] args:可以接收数据，提供程序的灵活性
                格式：java MainDemo hello world java
                      java MainDemo 10 20 30
    5.final关键字
        1)是最终的意思，可以修饰类，变量，方法。
        2)特点：
            A:它修饰的类，不能被继承。
            B:它修饰的变量，是一个常量。
            C:它修饰的方法，不能被重写。
        3)修饰变量
            A:局部变量
                a:基本类型：值不能发生改变
                b:引用类型：地址值不能发生改变，但是对象的内容是可以改变的
            B:成员变量
                a:只能初始化一次。
                b:常见的给值
                    定义的时候。(推荐)
                    构造方法中。

四、补充

    1.包
        1)其实就是文件夹
        2)作用：
            A:区分同名的类
            B:对类进行分类管理
                a:按照功能分
                b:按照模块分
        3)包的定义
            package 包名;
            多级包用.分开。
        4)注意事项
            A:package语句必须在文件中的第一条有效语句
            B:在一个java文件中，只能有一个package
            C:如果没有package，默认就是无包名
        5)带包的编译和运行
            A:手动式
            B:自动式(掌握)
                javac -d . HelloWorld.java
            
    2.导包
        1)多次使用一个带包的类非常麻烦，而Java提供了一个关键字import。
        2)格式：
            A:import 包名...类名;
            B:import 包名...*;（不建议）
        3)package,import,class的顺序
            package > import > class
    
    3.权限修饰符
        1)

权限修饰符

	本类	同一个包下	不同包下的子类	不同包下的无关类
private	√
默认	√	√
protected	√	√	√
public	√	√	√	√

        2)这四种权限修饰符在任意时刻只能出现一种。

    4.常见的修饰符
        1)分类：
            A:权限修饰符：private,默认,protected,public
            B:状态修饰符：static,final
            C:抽象修饰符：abstract
        2)常见的类及其组成的修饰
            A:类：
                默认,public,final,abstract        
                常用的：public
            B:成员变量：
                private,默认,protected,public,static,final
                常用的：private
            C:构造方法：
                private,默认,protected,public    
                常用的：public
            D:成员方法：
                private,默认,protected,public,static,final,abstract
                常用的：public
        3)另外比较常见的：
            public static final int NUM = 10;//常量
            public static void show() {}//静态方法
            public final void show() {}//不能被子类重写的方法
            public abstract void show();//抽象方法

笔记整理自传智。