javase_09(面向对象总结)

Java的环境配置 day01
 
 1.    环境配置有如下的三种方法：
 a)    我的电脑属性： 从path 环境中配置
 b)    利用临时的变量设置： set path = java的所在路径\bin%d%
 c)    定义批处理文件  ： 设置步骤如下：
 a)    set path = %cd%\H:\java\jdk1.7\bin
 b)    
 c)    start
 
 一．    java的环境搭配
 1.    安装jdk >1.jdk是java的开发和运行环境 >2.jre是java的运行环境
 2.    配置环境变量?为什么呢?方便在任意的目录下使用java工具
 a.    我的电脑—属性—高级—环境变量
 在已有的环境变量path的基础下，添加一个jdk\bin目录即可.
 这种方法较为一劳永逸
 技巧：为了日后修改方便，不需要总是修改path，可以首先定义一个环境变量 JAVA_HOME 把前面的路径保存下来.并且通过%JAVA_HOME%来动态的获取该变量
 b.    也可以通过临时环境变量，通过dos控制台，使用set命令即可。
 set path = (java的按照目录)jdk\bin;&path&;
 
 c.    如果是在别人的电脑去完成java开发，还不想配置java环境变量.咱们可以使用批处理来完成：
 a)    假设： a.bat 
 b)    set path = %cd%jdk\bin;%path%  %cd%代表获取当前目录.
 c)    为了避免了不让它一闪而过：start.
 
 二：转义字符
     1.\n：换行
     2.\t：tab键
     3.\b:退格键    
 
 
 三： 数据运算符
 
 & : 只有两边都为true结果为true，否则为false。
 |：只有两边为flase才为false,否则都为true
         ^ : 只有两边相同 结果为false，否则为true。
 
         
 
 Java基础知识 day02
 
 二．变量：
         在内存中所开辟的空间将常量值进行存储、方便运算。
         好处：该空间可以重复使用..
         定义格式：
                     数据类型    变量名    = 初始值
         使用变量的注意事项：
 1.    变量有自己的作用域
 2.    变量不能赋空值.
 
 基本数据类型：
 byte int long char short double boolean float
 引用数据类型：
 接口    类    数组
     
         什么时候需要定义变量：
         当数据不确定时,或者运算后的结果需要进行下一步的操作
         这时候就要定义一个变量将该不确定的数据进行存储。
 
 三.运算符：
 1.    算术运算符：
 1.    +：连接符
 2.    %取余： 任何数%2 结构非零急一
 3.    ++自增 (++a先运算后赋值 a++先赋值后运算)
 2.    赋值运算符：
 1.    int a,b;
 2.    a=b=c = 4;
 3.    i+=4; i=i+4;
 
 3．比较运算符：
         特点：运算后结构非false 或true
                 ==    相等于
 
 4.逻辑运算符
 & | ^ 这些运算符不仅仅可以代表boolean表达式，也可以进行位运算。
 &和&&：当左边为false时，&：两边的表达式都参与运算。&&右边的表达式不参与运算。
 |和||：当左边为true时，|：两边的表达式都参与运算。||右边的表达式不参与运算。
 ^:两边一样结果为false。
 
 5．位运算符
     左移：<<  3<<2=12  3<<4 = 48
     右移：>> 和 >>> 区别： 
 >>:右移后，空位按照移位前的最高位来填充。最高位为0，用0补。最高位为1用1来补    
 >>>:无符号右移,无论最高位是什么，都用0补。
     
 6.负数的由来：取反+1
 -6:         00000000    00000000    00000000    00000110
 取反：    11111111    11111111    11111111    11111001
 加一：    11111111    11111111    11111111    11111010
                                                     
 
 四.语句
 
     判断：if
 1.    if(条件表达式){}
 2.    if(条件表达式){}else{};
 3.    if(条件表达式){}else{}
 
 对于第二种格式：简化形式，三元运算符
         变量 =(条件表达式)? 表达式1 ：表达式2
 简化形式与非简化形式有如果不同：
 解答： 简化形式因为是一个运算，所以咱们必须要有一个结果。
 
 if(x >１)
     Y = 100;
 else
     Y = 200;
 Y =(x>1)? 100: 200;
 注意：无论条件表达式有多复杂，只要有true    ||flase 出现，则没问题.否则条件表达式会出错：if(x =1);
         
         选择:switch(表达式)
                 
                 switch(表达式)
                 {
                     case 1:
                         执行语句;
                         break;
                     case    2:
                         执行语句;
                         break;
                     case    3:
                         执行语句;
                         break;
                     default;
                         执行语句;
 }
 
                 特点：
 1.表达式运算四种类型的值:byet     int short char(它有一个自动型转换过程)
 2.case和default之间是可以没有任何的顺序，但是在运算期间，肯定会先读取第一个case    ,当case不匹配，会继续执行其他的case。当所有的case不匹配的时候.会运行default。
 3.switch语句结束的两个方式：a.读取switch语句大括号结束b.碰到break语句结束.注意:如果没有碰到break，也没有读取结束的时候，那么程序是一直往下面运行，直到程序运算完毕
 
         
 
             循环：while    du{}while; for
             
 1.    while(表达式){执行语句}(先判断后执行)
 2.    do{执行语句}while(条件表达式);(先执行一次,再判断)
 3.    for(初始化表达式;循环判断条件;循环后的操作表达式){}
 
 什么时候用这些语句呢?
     当对固定的几个值进行判断的时候，建议使用switch
     当对范围的判断，或者对运算后的真假进行判断的时候,我们需要用到if
     
     当需要执行语句多次的时候.我们使用到循环
     while与for循环是可以相互交换
     因为作用域的关系：
 在使用两个语句的时候有些区分，如果定义变量只为循环存在，循环结束后就没有意义。我们使用到for循环语句。
                 如果变量在循环后再执行别的运算，那么我们使用while比较好~
 
                 break：选择结构和循环结构
                 continue：循环结果：结束本次循环.继续下一次循环
 
         函数：
                 特点：
                         --类中的一个独立小程序
                         --只有被调用的时候才会运算
                         --可以重复的去运行
                 好处：
                         对代码进行封装,可以提高代码的复用性
                 格式：
                         返回值类型    函数名(参数类型    形式参数1)
 {
         执行语句;
         return 返回值;
 }
                 
 如果定义一个函数？
 1.    明确该功能函数运算后的结果。（明确返回值类型）
 2.    明确该功能实现的过程，是否需要有未知值参与运算（明确函数的参数类型）
 要定义一个加法运算功能
 
 int getSum(int x ,int y)
 {
     return x + y;
 }
 
 方法的重载：@overload(标记重载)
 特点：当多个函数的功能一致，只是参与运算不同的时候，为了提高代码的可阅读性,我们可以使用方法的重载.用参数来进行区分.    
 int getSum(int x,int y,int z)
 {
     return x + y + z;
 }
 
         函数的特点：
 有一种情况，函数执行一个功能，但没有具体的返回值。返回值类型不可以具体的来确定的时候,那么我们用void关键字来表示.那么函数的return 语句是可以忽略不写的.  也可以:return ;
 
 
 day03  数组
 
 五.数组： 其实就是同类型的一组数字
 
     同一种类型数据的集合，类型一定要一致。
 
     内存图：
             java划分了两片内存，方便了运算
 
             栈内存：存放局部变量，函数上和函数定义的变量都是局部变量
             变量一点使用完毕,自动清空。
             栈内存： new关键字所建立的,都称为实例.在堆内存里面存放的.
 
 
     数组常见的如下问题：
         角标越界异常:使用到数组中不存在的角标。
 (ArrayIndexOutOfBoundsException)   数组特有异常
 
 空指针异常：引用型变量等于null，也就是没有指向。
 （NullPointsException）
     ########
         本身就是一个容器，用来存储数据.
         特点：固定的长度.        
         好处：给元素进行编号，从零开始。同时也可以length属性获取数组的长度.
     
         什么时候使用数组？
         当数据较多的时候，通常是为了方便操作这些数据都需要进行临时存储.
         
         习惯：
                 通常操作数组都需要遍历，获取数组中的元素需要一个指针。
                 通常对指针的值的改变也就是更改了数组里边的值啦~~
 
 
 
 选择排序：
         int[]arr = {1,2,45,657,33,214,64,16,32,13};
 
         for(int i = 0;i<arr.length;i++)
         {
             for(int j = i+1;j<arr.length;j++)
             {
                 if(arr[j]>arr[i])
                 {
                     swap(arr,j,i);
                 }
             }
         }
 
 冒泡排序： bubbleSort
 
     public static int[] bubbleSort(int[]arr)
     {
             for(int i = 0;i<arr.length;i++)
             {
                     for(int j = 0;j<arr.length-i-1;j++)
                     {
                             if(arr[j]>arr[j+1])
                             {
                                     swap(arr,j,j+1);
                             }
                     }
             }
             return arr;
 
 
 day 04 面向对象
 面向对象：
 1.    符合现实中人民思考习惯的一种思想.
 2.    它将程序员的角色（执行者）转换成（指挥者）
 3.    将复杂的问题简单化.
 
 对象无处不在,一切皆对象
 
 对象是实实在在存在的个体,那么我们需要使用计算机语言来进行描述
 在java当中，描述事物是通过类来完成,在计算机中是通过new 类来创建对象.并且指挥对象完成事情.
 
 例如： 制造汽车，通过汽车来描述：图纸。对应的java中的类class
         通过图纸来产生汽车： 对象，对应的就是java在堆内存中所产生的实例
 
 通过java语言编写程序，其实就是不断的定义类,创建对象的一个过程。
 成员变量（事物的属性） 成员方法(事物的行为)。    
 
 对象的存在有什么好处？或者说怎么才叫做对象?
 对象可以用于封装数据.可以在对象中定义属性和行为,并指挥.
 
 在编写程序中，当要完成某个功能的时候,先看一下java是否提供了自有的对象.如果有,那么可以直接的去使用这个对象里面的功能.否则如果该对象不存在.那么我们需要定义一个对象，并将需要的功能封装到该对象中,以便对象的重复使用.。
 
 对象是如何使用呢?
 通过new 关键字来建立，并且通过 对象.成员变量 的形式操作对象所做的事情..
 
 
 匿名对象：
             其实就是一个没有名字的对象,可以理解为创建对象的简化形式.
             
 1.    当只对对象方法进行一次操作的时候可以使用
 a)    new  person();  
 2.    可以做为实际参数的传递:
 a)    public void show(new Person());
 
 
 封装：
     什么是封装呢?
             其实就是隐藏实现细节，提供了安全性
             
     在通过类来创建对象的时候，可以通过对象调用成员，也可以使用对象的属性
     为了提高安全性，所以避免了直接对属性进行访问：我们可以把它设计为私有private
 
     对外提供方法来间接访问age进行赋值！
         
         private int age ; 
         public void setAge(int age)
 {
     this.age = age;
 }
 
 public int  getAge()
 {
     retrun age;
 }
     在代码的体现：
             1.函数就是一个最小的封装体
             2.类本身就是一种封装
             3.包也是一种封装
             4.ssh框架也是一种封装.
             5.timcat服务器软件
 
 
 /*
 
         体现良好的封装！
 */
 
 class Person
 {
     private String name ;
     private int age;
     
 
     /*
             这是隐藏下来的代码~~
     */
     Person()
     {
         super();
     }
     public void setName(String name)
     {
         this.name = name;
     }
     public String getName()
     {
         return name ; //this.name
     }
 
     public void setAge(int age)
     {
         this.age = age;
     }
     public int getAge()
     {
         return age;
     }
 }
 class Demo5 
 {
     public static void main(String[] args) 
     {
         Person p = new Person();
         p.setName("kudy");
         String name = p.getName();
 
         p.setAge(18);
         int age = p.getAge();
     }
 }
 
 
 执行的过程：
 1.    加载Person .class文件到堆内存中
 2.    因为new，在堆内存中开辟空间，创建对象。在对象中出现了name 与age
 3.    对象中的属性默认初始化
 4.    对象中的属性显式初始化
 5.    构造函数初始化
 6.    创建引用变量，并将该对象的首地址给变量，该变量这时候就指向了对象。
 
 
 this语句代码什么?
                 1.this所在的函数所属对象的引用
                 2.this被那个对象调用.那this就代表那个对象
 
     A）this还可以用与区分成员变量与局部变量同名的情况
 
     B)什么时候使用this?
     当定义功能时，该变量内部使用了本类的对象,同时，this表示该对象
     
     C）this语句：
 在构造函数中，方便于构造函数调用,但注意：this语句只能在构造函数的第一位.因为要对执行的数据进行初始化.
 
 
 
 day05 面向对象
 1，    构造函数
 a.    函数名与类名相同
 b.    没有返回值
 c.    函数中没有return语句
 
 作用： 可以对对象进行初始化
 
 比喻：Person p = new Person();
         a,加载Person.class文件到堆内存中
         b,在堆内存中开辟空间，创建实例对象
 c,对对象的内容进行默认的初始化
             d,对对象的内容进行显式的初始化
             e,对对象自定义的内容进行初始化，通过构造函数来完成的.
             f,在栈内存中定义变量存入对象的地址值，指向该对象
 
     注意：
             在用class文件时，jvm会自动的在该类添加一个默认的构造函数（没有构造函数,你就创建不了对象的哦）该函数的形参是空的.
             构造函数可以通过this来进行互相的调用，是通过this语句来完成
             this的语句一定要放在构造函数的第一行
 
 
 2,static关键字
         特点：
             ---随着类的加载而加载，随着类的消失而消失，静态成员的声明周期最长
             ---优先于对象
             ---被所有的对象所共享
             ---可以直接通过类名来调用
     
         注意：
             ---静态方法只能访问静态的成员（因为我是不需要创建对象就可以使用的）
             ---静态方法中不能出现this，super关键字.因为静态方法没有所谓的对象
             ---主函数是静态的
 
         
 2，    设计模式：解决某类问题之间有效的方法.
 java中有23种设计模式
 
 单例设计模式：
 a)    私有化构造函数
 b)    定义一个静态私有化的本类对象
 c)    定义一个静态方法返回内部对象的地址
 
 
 
 
 class Singleton
 {
     private Singleton()
     {
         //私有化构造函数,避免创建对象！
     }
 
 
     private static Singleton singleton = new Singleton();
     public static Singleton getSingLeton()
     {
         return singleton;
     }
 }
 class Demo7 
 {
     public static void main(String[] args) 
     {
         Singleton s1 = Singleton.getSingLeton();
         Singleton s2 = Singleton.getSingLeton();
         System.out.println(s1== s2);
     }
 }
 
 3,静态的代码块:
             特点：随着类的加载而加载，执行一次，优先于函数
             作用：对于类的初始化
 
 
 4,内部类：
             其实就是一个类的内部中定义另外一个类，内部类可以定义在外部类里面
             内部类可以直接访问外部类的成员，那是因为内部类只有一个外部类的引用（类名.this）而外部类访问内部类的成员需要创建对象
 
     什么时候使用内部类？
                     描述事物时，该事物内部与还有事物，那么可以通过内部类来完成
 
     当内部类在成员位置上，可以被成员修饰符所修饰。    
     当内部类中定义了静态成员时，内部类是必须要静态的.但是静态内部类局限性
     但方法中里面定义了内部类，方法里面的属性内部类是不能所访问的.因为局部变量是存储在栈内存中,系统会不知道什么时候会被释放.那么我们如果定义成final 就是没问题.定义成final就是常量.是不能改变的量.是存储在堆内存中.
 
     
 day06面向对象（面向对象的总结）
 
 异常：
 
     异常的处理机制：
 
     1.可以在方法后面使用throws关键字，声明向外抛出一个异常
     2.可以使用try catch语句块捕获异常
         3.finally语句块的作用： finally需要结合try使用.不论如何finally当中的代码都是会被执行
     4.如果是运行时异常,那么jvm是自动的抛出一个异常对象.让虚拟机去处理.也可以自己手动的去处理.
 
     自定义异常：
 
     1.自定义编译时异常，定义一个类继承与Exception
 2.可以在程序中使用throw关键字向外抛出一个编译时异常对象,这时方法必须向外抛出一个异常
             throw关键字相当于return 
     
     异常的使用细节：
 因为都是为了多态而服务的,所以当父类型的引用指向子类型的对象的时候/jvm就分辨不清楚啦~~）
 
 1.    子类重写父类的方法.不能抛出被父类更多的方法.没抛,子类不能抛.父类抛了.子类可以不抛.要抛也只能抛父类一样的异常，或者父类异常的子类.
 2.    一个try语句可以跟多个catch语句一起来捕获异常
     3.try finally 可以嵌套使用.
     
     异常的使用总结：
 
     1.异常是在程序运算期间发生的错误，所有的异常类都是Throwable的子类
     2.error,java的虚拟机错误，比较严重。处理不了.不用处理。编译是不会出错
     3.Exception：异常{
 一个特殊的子类,RuntimeException这个类的所有的子类都是运行的时候异常,不必要处理,编译时不会报错.交给默认的处理程序.其它的子类都是编译时异常,比较严重的错误！在方法后面应该跑出去,我们在调用方法一定要处理.否则编译器会报错。
 }
     4.异常处理方式：try {} catch捕获异常,throws 向外抛出一个异常
     5.thorw 与throws 的区别?
                         throws声明方法向外抛出一个异常
                         throw和return一样,只不过是要创建一个对象
 注意：
                         抛出一个对象,一定需要在方法外面声明抛出一个异常.
 
     6.自定义异常:
     1.可以自己写一个类继承与Exception,这个类就是编译时异常
     2.可以自己写一个类继承于RuntimeException，这个类就是运算期间异常
 
         
 面试题目：
 
 1.请说说final 与 finalize 和 finally的区别？三者有什么共同点?
 解答： 除了单词有点像,他们都是没什么缘分的..
 1.final是java的修饰关键字.修饰类,类不能被继承.修饰属性.属性会编程常量.不能修改的值.修饰方法.这个方法不能被重写.
 2.finalize：是在Object类当中定义的一个方法,所有的类都是默认继承与Object类.也就是说：继承了这个方法.当对象被垃圾回收之前.jvm会自动的调用该对象的finalize方法,所以我们一般通过finalize来做一些内存释放的工作..
 3.finally ：java中的关键字，必须结合try语句一起来使用.写在finally代码中的语句.一定会被执行.除非jvm退出。
 
 class MyException extends Exception
 {
     public String getMessage()
     {
         return "上帝~~";
     }
 }
 
 class Student
 {
     public void readBook(int num) throws Exception
     {
         if(num >300 || num <1){
             throw new Exception(){ //返回一个对象
                 //匿名内部类.重写了父类的方法！
                 public String getMessage()
                 {
                         return "你在吹牛吗?";
                 }
         };
         }
         else
         {
                 System.out.println("好孩子！");
         }
         
     }
 
     public void eat(int week) throws MyException  //向外抛出去一个异常
     {
         if(week<1||week>7)
                 throw new MyException();  //结束,有了一个对象！
         else
             System.out.println("星期是正确的！！");
     }
 }
 class Demo10 
 {
     public static void main(String[] args) 
     {
         try
         {
             new Student().readBook(400);
         }
         catch (Exception e)
         {
             e.printStackTrace();
         }
     
 
     try
     {
         new Student().eat(88);
     } 
     catch (Exception e)   //父类型的引用所指向子类型的对象  Exception e = new MyException();
     {
         e.printStackTrace();
     }
 
     }
 }
 
 
 1.    封装性：
 1)类的封装：将属性都私有化(private)，防止外界的直接访问，对外提供s    et 与get方法。
 优点：隐藏内部实现过程，方便权限的管理
             
 2)方法的封装：在实现功能的时候，应该尽可能的多抽取方法，尽量将别人用不到的方法私有化，实现一个封装性。将提供方法进行功能调用方法设置为公有的public就可以
 优点：让类看起来更加的整洁，对外隐藏了实现的细节。
 
 2.    抽象：
 a)    为了描述显示的事物，在程序中通过对象来映射显示中类的事物（万物皆对象）
 b)    将一组特征相似的对象共同的特征和行为抽象出一个类来定义
 c)    类的成员变量（属性）来描述特征，用成员方法来描述对象的行为
 3.    继承：
 a)    使用extends 关键字让子类继承父类，子类就可以自动复用了父类的所有属性和方法（非私有）
 b)    子类实例化过程：
 1.    子类的构造方法一定会调用父类的构造方法,可以在第一行使用this（实参）来调用自己其他的构造方法，使用super(实参)来调用父类的构造方法
 2.    如果第一行没有声明，jvm会自动调用父类的无参的构造方法
 3.    子类和父类之间的转换
 1,可以将子类实例当做父类来用，反则不能.
 2,把子类当做父类来用时：调用方法是子类的（重写的关系）,这个是做了动态的绑定,如果是访问属性的（静态的绑定）也就说：调用的数父类的属性.
 3，把子类当做父类来使用时，不能调用子类特有方法，因为编译器会检查语法,发现该父类没有这个方法，会报错！
 4,如果是把子类当做父类来使用的时候，这时候可以强制类型转换，则再有把握：咱们都需要用instanceof来判断一些对象的类型。 
 4.    多态：
 1.    把子类当做父类来用
 2.    我们在编程无时无刻不使用多态，在定义一个方法形参的时候，为了便于方法的通用性，通常会将形参定义为父类类型，最好是接口类型，当调用方法的时候.那么就可以子类实例当做父类来使用，正因为有了多态，我们经常把子类当做父类来使用。所以有了以下的规定。
 ii.    返回值类型必须和父类的一致，或者是父类返回值类型的子类实例
 iii.    子类不能有比父类更加严格的访问权限,假设父类是 public 而你子类是：private  那么在传递参数的时候，有可能会因为访问权限而出错！所以java是不允许的.
 iv.    子类不能被父类抛出更多的异常.
 v.    异常： throw 抛出一个异常对象.方法外部也是需要向外声明抛出一个异常
 
 
 彩票的摇奖过程：
 
 import java.util.Random;
  class Lottery
 {
     private int poorCount;
     private int luckyPoorCount;
     private int[] poor;
     private int []luckPoor;
 
     //构造函数在构造摇奖的对象
     Lottery(int poorCount,int luckyPoorCount)
     {
             this.poorCount = poorCount;
             this.luckyPoorCount = luckyPoorCount;
             setPoor();
     }
 
     //填充奖池
     private void setPoor()
     {
             /*
                     怎么做?
             1.根据poorCount创建数组,
             2.将1~poorCount填充数组,
             */
         int[] arr = new int[poorCount];
         for(int i=0; i<poorCount; i++)
             arr[i] = i+1; //37个数字
         poor = arr;
         luckPoor = new int[luckyPoorCount];
     }
 
     public void run()
     {
             //摇出所有的中奖号码放在中奖池中
             setLuckyPoor();
             //输出所有的中奖号码
             listLuckyPoor();
     }
 
     //获得所有的中奖号码~~
     public void setLuckyPoor()
     {
         //1.定义循环,循环次数是luckyPoorCount
         for(int i=0; i<luckyPoorCount; i++)
         {
                 //1.产生一个随机的中奖号码
                 int luckyNumber = getLuckyNumber();
                 //2.将中奖号码从里面删除
                 deleteNumber(luckyNumber);
                 //3.将中奖号码放在奖池中
                 luckPoor[i] = luckyNumber;
         }    
     }
 
     private int getLuckyNumber()
     {
         int randomNum = new Random().nextInt(poor.length);
         return poor[randomNum];
     }
 
     private void deleteNumber(int luckyNumber)
     {
         int[] newArr = new int[poor.length-1];
         int pos = 0;
         for(int i=0; i<poor.length; i++)
         {
                 if(poor[i] == luckyNumber)
                 continue;
                 newArr[pos++] = poor[i]; //幸运的数字
         }
         poor = newArr; 
     }
 
     private void  listLuckyPoor()
     {
             StringBuffer sb = new StringBuffer();
             for(int num : luckPoor)
                 sb.append(num +" ");
             System.out.println("中奖的号码为：");
             System.out.println(sb);
     }
 }
 
 public class Demo11 
 {
     public static void main(String[] args) 
     {
         Lottery lottery = new Lottery(36,7);
         lottery.run();
     }
 }