初学JAVA02

编程思想：

    需求 --> 建立思路 --> 目标代码面向过程的思想：    自顶向下，逐步求精                只适用于相对简单的应用面向对象的思想：    对象：        1、一切客观存在的事物        2、所有的对象都拥有自己的特征和行为        属性：有什么，由什么组成            对象的属性可能又是一个对象        方法：能做什么            对象的方法的使用者又是一个对象    客观世界是由对象组成的        1.小对象组成大对象        2.对象间彼此方法调用    解决客观问题：    面向对象的思想        1.把解决问题所需要的对象准备好        2.对象间如何配合，完成需求        计算机需求 来源于 客观世界            淘宝 解决 人在日常生活中的需求             QQ  解决 人和人之间的交流        解决计算机问题，同样可以采用面向对象的思想

计算机的对象：

    JVM中连续的存储空间(数据)    ——  代表生活中的对象    生活中的对象在计算机中的抽象        学生管理系统：生活中的对象：学生（活生生的对象）                      计算机：属性：保留：姓名，班级，性别，年龄                                    舍弃：身高，体重，发型……        在线考试系统：生活中的对象：试卷，学生，老师                      计算机：对象：试卷（属性：考题）                                    学生（方法：答题，属性：成绩）                                    老师（方法：判卷）面向对象的特点：    对象是各司其职的，对象应该保持简单性 对象的高内聚    弱耦合性 —— 对象和对象之间的联系应该尽量弱化                    主板和硬盘，尽量插拔，而不是焊接                    企业和商品，商品被淘汰，企业必须有新商品    可重用性  ——    挪用以前的对象    可扩展性  ——    在原先对象基础上开发新功能

类

    1.对象共性的抽象 -- 类是多个相似或相同对象共性的抽象，保留我们关注的部分            学生：姓名、性别、年龄    2.客观对象在人脑中的主观反映    类是人对对象的认识    3.类是对象的模板(对象根据类来创建)

如何编写一个类

class 类名{    类的内容}    属性：实例变量|成员变量：(类内部，方法外部)            //局部变量：            1.有默认值（和数组默认值规则一样）                //先赋值后使用            2.作用范围：整个类内部，与定义位置无关            //作用范围：从定义开始到定义的代码块结束            3.可以和局部变量发生命名冲突，冲突时局部优先    //两个局部变量重合范围下命名不能冲突        class Student{            String name;            int age;        }    方法：                与函数不同，去掉了static        方法的声明：对象能做什么            修饰符 返回值类型 方法名（参数表） 抛出的异常        方法的实现：对象怎么做        public void test(){            System.out.println("HelloWorld");        }        方法的重载（overload）（编译时多态）            eg：吃（饭、药、甘蔗）            允许定义多个同名的方法(方法名称相同)            参数表不同：                1.参数个数不同        例如 void study()和 void study(int n)                2.参数类型不同        例如 void study(int n)和 void study(double d)                3.参数类型顺序不同    例如 void study(int n, double d)和 void study(double d, int n)                形参名不同不是重载    void study(int a)与 void study(int b)            class Test{              public void test(int i){}              public void test(String s){}               }            由编译器在程序编译时，根据实参的类型选择合适的方法调用            向上就近匹配原则（类型相近），，避免混淆            自动类型提升(实参传形参)            作用：让一个对象的同类方法，由于参数表的不同造成的差异，对用户屏蔽！                    System.out.println();                    System.out.println("HelloWorld");                    System.out.println(true);                    System.out.println(12);    构造方法：（一种比较特殊的方法）    //一般方法：剪发(人生可以多次)；构造方法：剪脐带(人生仅一次)        1.没有返回值类型        2.方法名必须和类名相同        3.不允许手工调用，必需使用new在创建对象的过程中自动调用        如果一个类没有定义任何构造方法，系统会默认添加一个公开无参构造方法        如果有写出明确的构造方法，默认的构造方法就不再默认了        new 构造方法名(实参列表);        class Test{          public Test(int i){}          public Test(){}           }

对象创建的语法：

    Student s = new Student();    Student s = new Student("zhangsan",18);对象的创建过程：    1.分配空间        所有的实例变量被赋予了默认值    2.初始化属性    所有的实例变量被赋予初始值(可省略)    3.调用构造方法    实例变量常常被第三次赋值                    构造方法经常用来为属性赋值

变量按类型划分：

    简单变量      ：存值                            int a = 10;                            int b = a;                            b++;                            System.out.println(a);        //10    对象变量(引用)：存对象的地址                            Student s1 = new Student();        //s1存的首地址1A2B3C4D                            Student s2 = s1;                //s2存的首地址1A2B3C4D                            s2.age++;                        //age=21                            System.out.println(s1.age);        //21                            class Student{                                int age = 20;                            }Java中参数的传递规则：    简单类型的参数：传值    对象类型的参数：传地址 传引用    实参和形参指向同一对象

this关键字

    1.引用  指向当前对象        当实例变量和局部变量命名冲突时，用this.表示实例变量    2.用在构造方法中            this(参数) —— 调用本类其他构造方法（必须是构造方法中的第一个语句）                class Test{                    public Test(int i){                          this();    //调用无参构造方法                    }                    public Test(){}                   }    3.this()不能够递归调用

面向对象的三大特性：(三大基石)

    封装        任何对象都有明确的边界(分为对象内部、对象外部)内外部互不影响            人(边界：皮肤)            房间(边界：地板、墙、天花板)        明确边界使系统变得简单            湖-扔石子-波纹扩散-扩散到边界，不会继续扩散，不会引起湖边土(外部)的变化        粒度(太大和太小都不合适，粒度太大使对象更为复杂，粒度太小使对象简单但系统更为复杂)            公司部门的多与少        封装的作用：            对象的边界 对 对象的内部起到保护的作用(数据隐藏)            尽可能的隐藏类的内部实现，以控制用户对对象的访问和修改的权限和程度                public    公开的 不受边界约束                private    私有的 只能在本类内部访问，严格受到边界的限制                属性私有，提供公开的setXXX/getXXX用来访问属性                    private String password="123456";                    public String getPassword(){                        return password;                    }                    public void setPassword(String password){                        this.password=password;                    }                方法私有，适用于只给本类调用                    人要呼吸/消化                方法公开：声明是公开的，实现是隐藏的                          实现的改变对架构的影响最小    继承        父类--子类 => 一般--特殊        父类：子类的共性抽象出来    //子类为了扩展父类的功能        class Dog extends Animal        所有子类能够访问的父类属性和方法，即是子类从父类中继承到的属性和方法            访问权限（修饰符）：从严到宽            private   私有的，  只能在本类内部访问，            不能被继承            (default) 默认的，  同包package,可以访问,            可被同包子类可以继承            protected 受保护的，同包+不同包的子类,可以访问，    可以被继承            public    公开的，  到处可访问的                    可以被继承的        构造方法不能继承！        创建子类对象，必须先创建父类对象            父类对象成为子类对象的一部分        方法的覆盖(Override) | 方法的重写            子类用特殊的方法实现 替换掉 父类继承给它的一般的方法实现            1.返回值类型、方法名、参数表 要和父类相同            2.访问修饰符要相同或更宽（参考4个访问权限修饰符）        Java中的单继承(目的：简单)            一个类最多只能有一个直接父类   --- 类之间会形成简单的树状结构            class B extends A{}            A<--B<--C    C是B的子类，B是A的子类            不能这样：class C extends B,A{}  ×    多态 (polymorphic)        子类的对象可以看做是父类的对象(狗--动物)            子类对象可以放入父类引用            Animal a = new Dog();        多态的语法：            1.实际类型不会改变            2.编译时以引用类型为主，只能调用引用类型中有的方法，编译时多态(方法的重载)            3.运行时以实际类型为主，调用实际类中的方法，运行时多态            ---------------------------------------------------------            1.对象自身的类型不变            2.通过引用调用方法，只能调用引用类型中声明的方法    ---  a只调用animal的方法            3.方法调用时，如果对象实际类型中对父类方法进行类覆盖，那么调用对象实际类型中的方法            子类引用赋值给父类引用，可以直接赋值(这是多态的基本用法)        ----  a=d;            父类引用赋值给子类引用，必须强制类型转换  -- 保证编译通过，但是运行可能发生类型转换异常                                                        ----  Dog d = (Dog)a;                在强制类型转换之前，可以用 instanceof (二元运算符，”是不是“)判断，从而避免类型转换异常                    引用 instanceof 类名    -- 结果：boolean类型(true | false)                        a instanceof Dog -- 判断a引用所装的对象是不是Dog        多态的作用：            将不同的子类对象统一看做父类对象，屏蔽了不同子类的差异        多态的常见用法：            1.多态用在方法参数上 -- 形参可以是父类引用，实参可以传子类对象                m(Animal a):可以用A的任何子类对象作为参数                取款(银联卡)  -- 银联卡是父类，包括招行卡、建行卡等            2.多态用在方法的返回值上                Animal m()：m方法完全可以返回Animal的某个子类对象                钱 取款(银联卡)  -- 取款返回的钱是父类，包括人民币、美元等

对象的构造过程：(对象的创建过程的升级版)

    1.分配空间        本类+父类  一并分配   所有的属性都被赋予了默认值    2.递归的构造父类对象(第2步-第4步)    3.初始化本类属性        所有的本类属性被赋予初始值    4.调用本类的构造方法    实例变量常常被第三次赋值        A<--B<--C    C是B的子类，B是A的子类        构造C对象步骤：            分配空间            构造B对象(构造A对象(构造A的父类对象(无)--初始化A属性--调用A构造方法)--初始化B属性--调用B构造方法)            初始化C属性            调用C构造方法        ---------------------------            分配空间            初始化A属性            调用A构造方法            初始化B属性            调用B构造方法            初始化C属性            调用C构造方法

super关键字

    1.引用：父类对象        用在访问父类被遮盖的属性 或 调用父类被覆盖的方法            super.name            super.show();    2.用在构造方法中，用来指定调用父类的哪一个构造方法      (必须是构造方法中的第一个语句)        常用来把构造参数传给父类，去设置父类的属性        如果一个构造方法的第一句话，不是this(参数)，也不是super(参数)，系统会默认添加super();                                                                        (即默认调用父类无参的构造方法)        总结：Java程序中，系统会默认添加的语句：                1.构造方法中，第一句默认super();                2.一个类，会默认添加构造方法（空的、公开的、无参的）                3.系统为每个程序默认添加 import java.lang.*;

修饰符

    访问修饰符:        private      可以修饰 属性、方法、构造方法        (default) 可以修饰 变量、方法、构造方法、类        protected 可以修饰 属性、方法、构造方法        public       可以修饰 属性、方法、构造方法、类    static 静态的        修饰 1.属性：类变量 —— 全类共有  —— 有默认值                    允许直接用类名访问，(eg: Test.num)                        class Test{                            static int num;        //整个类用同一个变量num                        }                static int a=10; —— 整个类用同一个变量a                eg：学生在计算机室，一人一台电脑(用实例变量)，但老师只有一个(类变量，静态属性)                    中国人，一个母亲(实例变量)，祖国母亲(静态变量)                属性(实例变量、类变量)                    实例变量是在创建对象时出现                    类变量是在类加载的时候出现                    类加载：                        当JVM第一次使用一个类时，需要通过CLASSPATH找到这个类对应的.class文件，                        把这个文件中包含的类的信息读入JVM中并保存下来。                        一般的说，一个类只会加载一次！                    类变量是在类加载的时候分配空间，并且初始化                    类加载的时机：                        1.创建类的对象                        2.访问类的静态成员(静态属性、静态方法)                        3.加载子类必须先加载父类                        4.如果仅仅是声明类的引用，不会类加载                        ……            2.方法：静态方法(不包括构造方法)                1)允许直接用类名访问，(eg: MyClass.print())                2)在静态方法中，只能访问类的静态成员!                    在静态方法中不能使用 this 关键字!                3)静态方法只能被子类的静态方法覆盖，而且没有多态(不适用于多态语法第三条)                    非静态方法只能被非静态方法覆盖                对引用 调用 其静态方法，仅相当于对引用的引用类型 调用静态方法(没有多态)                    public class Class{                        public static void main(String[] args){                            Super s=new Sub();                            s.method();            //相当于Super.method();                        }                    }                    class Super{                        public static void method(){    //static静态                            ……                        }                    }                    class Sub extends Super{                        public static void method(){    //static静态                            ……                        }                    }            3.初始代码块：                静态初始代码块中的代码，仅仅在类加载的时候执行一次                    public class Class{                        public static void main(String[] args){                            new MyClass();    //打印hhhh    MyClass()                            new MyClass();    //打印MyClass()                        }                    }                    class MyClass{                        static{                                //初始代码块{}                            System.out.println("hhhh");        //加载一次，即只打印一次                        }                        public MyClass(){                            System.out.println("MyClass()");                        }                    }    final    最终的        修饰 1.变量(实例变量、类变量、局部变量):常量(全大写)                    一旦赋值，不能改变                    对于 final 属性，jvm不会提供默认值                    如果 final 实例变量，可以在初始化属性或是构造方法中赋值                        class MyClass{                            final int A=10;     //初始化属性(不建议使用，会浪费空间，可以使用static变成类变量)                        }                        ---------------------------                        class MyClass{                            final int A;                            public MyClass(int a){    //构造方法                                this.A=a;                            }                        }                    如果 final 类变量，可以在初始化属性或是静态初始代码块中赋值                        class MyClass{                            static final int A=10;    //初始化属性                        }                        ---------------------------------                        class MyClass{                            static final int A;                            static{            //静态初始代码块                                A=10;                            }                        }            2.方法                该方法不能被子类覆盖            3.类                该类不能被子类继承(可以理解为：末端类)                真理：一个 final 类中，里面的方法都是 final                    解释：final 类没有子类，所以谈不上方法覆盖，即方法也是 final        final 应用(String)：            String字符串 是 final String(资源共享--串池 intern -- 节省空间)                串池：不可变性：对创建好的字符串重复利用，减少创建String时间消耗的性能                节省空间(正)：  String a1="abc";    //此时a1指向串池的"abc"                                String a2="abc";    //此时a2指向串池的"abc"    -- 减少重复对象的创建                                a1+="d"                //此时a1指向串池的"abcd"                                System.out.println(a1);    //abcd                                System.out.println(a2);    //abc                节省空间(反)：String s="a";    //此时s指向串池的"a"                                s+="b";        //此时s指向串池的"ab"    -- 不断创建新的对象                                s+="c";        //此时s指向串池的"abc"                                s+="d";        //此时s指向串池的"abcd"                                System.out.println(s);    //abcd                        -------------------------------------------------                        解决：String s="a";    //此时s指向串池的"a"                            StringBuffer sb=new StringBuffer(s);    //利用s作为构造参数，创建StringBuffer对象                            sb.append("b");    //调用append方法进行字符串的追加                            sb.append("c");                            sb.append("d");                            s=sb.toString(); //调用toString方法，把StringBuffer转成String。此时s指向abcd                            System.out.println(s);    //abcd    abstract 抽象的        修饰 1.类：抽象类(可以理解为：一个类的半成品)                只能声明引用，不能创建对象            2.方法：抽象方法                只有声明，没有实现(实现部分写";")                    public abstract void method();            抽象类和抽象方法的关系：                1.如果一个类中有抽象方法，那么这个类必须是抽象类(有抽象方法的类一定是抽象类)                (因为抽象方法只有声明，没有实现，即类是半成品(抽象类))                但是，抽象类中未必一定会有抽象方法！                抽象类中可以存在构造方法(子类可以调用)                2.子类继承抽象类，要么成为抽象类，要么就必须实现父类中声明的所有抽象方法                    ……main{                        Super s;        //声明引用                        s=new Sub();    //创建对象                        s.method();        //Sub    //符合多态语法                    }                    abstract class Super{    //抽象类                        public abstract void method();    //抽象方法                    }                    class Sub extends Super{                        public void method(){    //方法覆盖                            System.out.println("Sub");                        }                    }        抽象的作用：(配合多态使用)            利用 abstract，把方法声明抽象到父类中，而方法实现留在子类，这样可以更好地体现"共性放在父类"原则！                动物(抽象类) 的吃(抽象方法) 和 狗(子类) 的吃(方法覆盖)                形状(抽象类) 的面积(抽象方法) 和 圆、矩形、正方形(子类) 的面积(方法覆盖)修饰符组合：    以方法为例：(三个修饰符都可以修饰方法(但不包括构造方法))        final 、 static 、 private 都不能和 abstract 联用        final 、 static 、 private 可以联用