Java第二周学习

 多维数组：二维数组                   
   语法: 
    动态初始化:
     数据类型[][] 变量名 = new 数据类型[][];  
    第一个[] 代表一个二维数组中 有几个 一维数组;（行）
    第二个[] 代表一个一维数组中 有几个 元素;  （列） 
     静态初始化:   
       (第一种方法)数据类型[][] 变量名 = { {元素 } , {元素 }};
       (第二种方法)int[][] 变量名 = new int[][]{{元素},{元素}};   
=============================================================
排序算法：
    1.内存排序
    (1)冒泡排序：相邻的两个数比较，将较大的数向后移动，放到整个数组的末尾。
         //控制的比较次数
            for(int i = 0;i < arr.length-1 ;i++){ 模板代码
                 //获取元素， 和 索引
                 for( int j = 0 ;j < arr.length-1-i  ;  j++){
                     if(arr[j] > arr[ j + 1]){
                          int temp = arr[j];  
                          arr[j] = arr[j+1]; //替换
                          arr[j+1] = temp;
                     }
                 }
            }
         //输出排序后的数组
            for(int i = 0 ;i < arr.length ;i++){
                Sytem.out.println(arr[i]);
            }
======================================================================
    (2)选择排序：找到整个数组中， 元素最小值的下标，然后拿着这个元素，
        (不稳定)       跟第一个有序序列比较，如果小，就交换位置，不小，就继续比较。
             
             //先假设第一个数就是最小的元素
             int[] arr = {5,4,23,4,23,13,1,9};
             
                 for(int i = 0; i < arr.length ;i++){
                      int min = i; //记录最小的下标
                      for(int j = i+1 ; j < arr.length; j++){
                         if(arr[min] > arr[j]){
                          min = j;
                            }
                         }
                          int temp = arr[i]; // 1 
                          arr[i] = arr[min];
                          arr[min] = temp;    
                     }    
                 //输出排序后的数组
                      for(int i = 0 ;i < arr.length ;i++){
                         Sytem.out.println(arr[i]);
                     }
=====================================================================
    (3)插入排序：将后面的元素与前面的元素作比较，如果比前面的数小，就插入到前面去
               //假设第一个数是有序的，将第二个数与前面的数作比较
        int[] arr = {3,3,12,2,35,1,2};
        for(int i = 1 ; i < arr.length; i++){
                //记录一下第二个元素
                int temp = arr[i];
                int j = i; //j 另一个数的下标
                while(j > 0 && temp < arr[j-1]){
                    arr[j] = arr[j-1];     
                   j--;
                }
                //由于 j-- 了   从 1 --> 0
                arr[j] = temp;
        }
        for(int i = 0;i < arr.length;i++){
               System.out.println(arr[i]);
           }
======================================================================
java特性：1：跨平台。2：纯面向对象语言
面向对象(Object Oriented Programming)OOP    
       (以....的方式 去做事)
       对象：程序中的一个具体的事物，可视可触碰。
什么是面向对象：
        就是当我们遇到一个问题的时候，先不要着急解决问题，先寻找问题域的 ‘对象’；
对象是通过类来构建的；

类是对象的描述(概念)、抽象
对象是类的具体实例。
在Java中如何构建一个类：
  访问修饰符 类名    class {
      //类的首字母要大写
  }
  public class Person{
  
  }
创建对象：
   类 类型  变量名 = new 类名(); 
    Person person= new  Person();
    person.run();
    person.say();
   Java中引用数据类型：数组,类,所有的类都是引用数据类型
==================================================================
 类的结构：5个部分
      1.成员属性(函数)
        根据具体对象来构思有什么属性。
      2.成员方法(行为)也称为普通方法
        (1)无返回值无参数:方法不需要复用,方法运行时,不需要外界的参数
           public void run(){
           
           }
        (2)无返回值有参数：方法不需要复用,方法运行时,需要外界的参数
           public void run(参数列表){
           
        }
        (3)有返回值无参数：方法需要复用,方法运行时,不需要外界的参数
        public 数据类型 buy(){
           return 值;
        }
        (4)有返回值有参数：方法需要复用,方法运行时,需要外界的参数
        public 数据类型 buy(参数列表){
            return 值;
        }
        方法的重载：同一个类中,方法名相同,参数列表不同,
                 不同指的是：参数的个数不同,参数的类型不同,参数的顺序不同
                 这就叫方法的重载,跟返回值无关。
      3.构造方法：
            访问修饰符 类名(参数列表){
            
            }
            在一个类中,构造方法是类的组成部分之一,如果我们不定义,那么系统会给我们默认提供一个无参的构造方法
            public Xxx(){
            }
            在编写类的时候,不管你构造了多少个构造方法,记得留出一个无参的构造方法。
           方法的调用：
               普通方法的调用：
                  public void eat(){
                  system.out.println("jfnsln");
                     sleep();
                  }
                  public void sleep(){
                  system.out.println("fshfvhs");           
                  eat();
                  }                                      (栈溢出)    
                普通方法可以互相调用,但不能相互一起调用,否则会出现StackOverflowError错误
               构造方法的调用：
                   必须是多的调用少的,必须用this();this();必须放在第一行。
                 构造方法可以调用普通方法,普通方法不可以调用构造方法
      4.静态块儿：
            static关键字修饰的 东西,在jvm虚拟机中优先加载,只加载一次
            static可以修饰成员属性--->静态属性
            static可以修饰普通方法--->静态方法
            static可以修饰游离块儿
            static{}
            
            可以直接通过 类名.方法 直接使用， 目的就是为了方便
            静态方法只能加载静态资源
        
        
        
        
      5.游离块儿(构造块儿)：
                  {  }
            一个类中 可以有多个静态块儿，多个游离块儿， 会按照顺序以次执行
            但是静态块儿只会加载一次， 游离块儿，new 几次就执行几次
            一个类只要运行了某个方法 ，或属性，就一定会加载静态块儿              
            游离块儿 只有 new 的 才会执行
            静态方法 只能加载静态资源
            非静态方法，也可以静态资源，和 非静态资源
======================================================================
属性的访问器：getter和setter方法。(私有属性时private)
        private String name;
        private int age;
        public Person(){
        }
         public String gerName(){
            return name; 
         }
         public void setName(String name){
            this.name = name;
         }
         public int getAge(){
            return age;
         }
         public void setAge(int age){
            this.age = age;
         }         
========================================================================
高级特性:  
   1.封装:
        快递打包， 让当前物品私密化;
        封装主要就是为了保证 程序的  安全性，并提高程序灵活性和 可拓展性，可维护性
        这样外界，可以简单操作，很方便
        
    jar包; 
        
      过程: 工程鼠标右键，Export  ----> jar 
              jar File ----> 选择存储位置  并给 文件起名字
                执行即可          
      使用jar包:  创建一个工程 ，在工程中 创建 lib 文件夹
                  将jar包复制到其中， 鼠标右键 ，add to Build path
                 
                 这时 你就可以创建一个测试类，使用过jar包中的 工具
==============================================================================
   2.继承：
        增加程序的延展性,减少模板代码的编写
        在Java中通过extends关键字实现继承
        方法的重载 和 方法的重写有什么区别? 
  
 什么是方法的重写? 
   在继承中，方法名相同，参数列表相同(个数， 顺序， 类型必须相同)
   返回值相同(类型相同) ，就是 方法方法的 重写
     
    重载是在 同一个类中，与返回值无关。
    重写是在继承中，返回值相同。

    继承中:  属性  和  方法的 继承        
    在继承中 构造方法 不可以被 继承，因为构造方法
    *** 在java中 不支持多继承，但支持多重继承
 super(); 调用父类的构造方法
 
 在子类中 想要调用父类的 属性和方法 ，需要使用 super.xxx
 
 this 代表当前对象
 this(); 调用当前类的构造器
 
 在Java中任何类都有一个父类 Object类---基类，根类
 如果手动继承了某个类，那么这个类的父类只能是继承的那个类，object类就自动变成了爷爷类。