面向对象浅析之类的组成成分--愚见

2.类的成分 :属性 方法 构造器 代码块 内部类;
            2.1 属性    
                声明格式:修饰符 (其他的关键字:static final) 数据类型 变量名 ;
                ①变量的分类:
                    A.成员变量(属性 Field)  vs  局部变量(方法中的形参、 方法内部定义的变量、代码块中定义的变量)
                        Field及局部变量的异同:
                                同:    
                                    a.遵循变量声明的格式;
                                    b.都有具体的作用域;
                                异:
                                    a.声明的位置不同 -- 成员变量声明于类中方法之外  vs 局部变量声明于(方法中的形参、 方法内部定义的变量、代码块中定义的变量);
                                    b.修饰符不同 --成员变量具有修饰符:public protected 缺省 private vs 局部变量没有修饰符，它与所在的方法的修饰符一致;
                                    c.初始化值 --成员变量在声明的同时，若 没有显示的赋值，则具有默认的初始化值  vs 局部变量没有默认的初始化值，在使用之前必须显示的赋初值;
                                    d.二者载内存中所占的位置不同--成员变量位于 堆内存 中  vs 局部变量位于栈内存中;
                    B.基本数据类型  vs 引用数据类型
                        a.基本数据类型: byte short char int long float double boolean
                            默认初值分别为: 0  0  '' 0  0L  0.0f 0.0  false
                        b.引用型数据类型: 数组 、 类 、 接口 默认初值:null
                ②属性的声明: 修饰符 数据类型 变量名  =  初始化值 ;//java是强数据类型的语言;
                ③属性的初始化及赋值操作: 1.默认的初始化 2.显示的初始化、代码块的初始化(二者按先后顺序执行)3.构造器的初始化  4.调用方法、属性的赋值;
            2.2 方法
                ① 方法的声明格式:
                        修饰符 (其他的关键字:static、final、abstract) 返回值类型或void 方法名 (形参列表){
                                //方法体;
                        }
                ②方法的重载(overload) vs 方法的重写(overwrite)
                    方法的重载:
                        每个重载的方法的方法名相同，而参数列表不同(参数列表不同，即参数的个数或参数的数据类型不同，二者满足其一或都满足即可 );    
                        注:
                            a.方法的重载位于同一个类中;
                            b.方法名相同;
                            c.参数不同(具体见上);
                            d.方法的重载和方法的返回值类型无关;
                    方法的重写:
                        前提:子类继承父类或有类实现了接口;
                        规则:
                            a.要求子类中重写的方法"返回值类型 方法名(参数列表)" 与父类中被重写的方法保持一致;
                            b.子类中重写的方法的"权限修饰符"  不得小于 父类中被重写的方法的权限修饰符;
                            c.若父类中被重写的方法抛出异常，则子类中重写的方法抛出的异常类型不得大于父类中被重写方法的异常类型;    

                            d.要求子类中重写的方法和父类中被重写的方法 同为 "静态的" 及 "非静态的";

                  ③方法的参数传递机制:
                    值传递:
                        a.基本数据类型的值传递:
                        b.引用数据类型的值传递:
                        eg: 以下代码说清了两种类型的值传递，此乃博主之愚见，还望各位海涵!
                        package com.yy.javase;
                        public class TestPerson{
                            public static void main(String args[]){
                            
                                        TestPerson tp = new TestPerson();
                                        Person p = new Person();//调用了Person类中，无参的构造器来创建对象;
                                        //此时通过"p.方法名(实参)"的方式来调用Person类中的方法，
                                        //与此同时，把实参值10就传给了Person类中形参age,此时age是局部变量只在方法内部有效，赋值给"this.age"，
                                        //这里有个this关键字，之后会在后面的文章中说明,读者只需明白这个 基本类型的值传递;
                                        p.setAge(10);
                                        //此时p为Person类的对象，对象是引用型数据类型，存放的是指向堆内存中给对象的属性的地址值，此时把p的值传给person
                                        //之后person就获得了和p对象一样的地址值,就可以调用p对象的方法和属性;
                                        tp.setPerson(p);
                            }
                            public void setPerson(Person person){
                                System.out.println("他的名字:"+person.getName());
                            }
                                    
                        }
                        class Person{
                            private String name;
                            private int age;
                            
                            public Person(){
                                super();
                            }
                            
                            public Person(String name,int age){
                                super();
                                this.name = name;
                                this.age = age;
                            }
                            public void setName(String name){
                                this.name = name;
                            }
                            public String getName(){
                                return name;
                            }
                            public void setAge(int age){
                                this.age = age;
                            }
                            public int getAge(){
                                return age;
                            }

                        }
                      

            2.3 构造器
                ①构造器的格式:
                        修饰符 类名(){
                            //方法体;
                        }
                ②构造器的作用:
                        a.创建对象;
                        b.给所创建对象的属性赋初值;
                        注:
                            a.若一个类中没有显示的定义构造器，系统会默认提供一个无参的构造器;
                                eg: public Person(){
                                    super();
                                }
                            b.若类中已经显示的定义了一个构造器，则系统将不会提供默认的无参构造器，一般在类中我们尽量要提供一个无参的构造器;
                            c.类中的构造器也可以构成重载;
            2.4 代码块(初始化块)
                ①代码块的分类:
                        a.静态代码块:
                            1.随着类的加载而加载，且只加载一次;
                            2.若类中有多个静态代码块，则按顺序执行;
                            3.静态代码块中只能执行静态的结构;
                            4.静态代码块的执行早于非静态的代码块;
                            5.静态代码块中可以有输出语句;
                        b.非静态代码块:
                            1.每创建一个对象就会加载一次非静态的代码块;
                            2.若类中有多个非静态代码块则多个代码块之间按顺序结构执行;
                            3.非静态代码块的执行早于构造器的执行，晚于静态代码块的执行;
                            4.非静态代码块中可以对类的属性进行初始化操作;
                            5.非静态代码块中可以有输出语句;
                注:代码块 只能被 static 关键字 来修饰;