JAVA(3)

接口注意事项：

1.接口不能被实例化

2.接口中所有的方法都不能有主体  （不能有{ }）

3.一个类可以实现多个接口

4.接口中可以有变量<但变量不能用private和protected修饰>

附加：

接口中的变量，本质上都是static的，而且是final，不管加不加static修饰

在java开发中，常把经常用的变量定义在接口中，作为全局变量使用。

<访问形式：接口名.变量名>

5.一个接口不能继承其他的类，但是可以继承别的接口

抽象类中可以有实现了的方法

接口中的方法一个都不能被实现

接口中定义变量有特殊要求

接口语法：

class  类名  implement  接口 {

方法；

变量；

}

小结：

接口是更加抽象的抽象的类

抽象类里的方法可以有方法体

接口里的所有方法都没有方法体

接口体现了程序设计的多态和高内聚低耦合的设计思想

package com.test4;
public class Test{

   public static void main(String[] args){

   }
 }
interface Fish
{
    public void swimming();
 }
interface Bird
{
   public void fly();
 }
class Monkey
{
   int name;
   public void jump()
   {
      System.out.println("ABC");
    }
 }
class LittleMonkey extends Monkey implement Fish,Bird
{
   public void swimming(){
    }
   public void fly(){
   }
 }

java的继承是单继承（一个类最多只能有一个父类）

final-概念

final可以修饰变量或方

使用final可以避免被子类修改：

class Aaa
{
   //给方法用final修饰，表示不可以被修改，不可被覆盖
   final public void sendMes()
   {
      System.out.println("发送消息");
    }
 }

final使用：

1.当不希望父类的某个方法被子类覆盖（override）时，使用final关键字修饰

2.当不希望类的某个变量的值被修改，可以用final修饰 <final public void xxx()>

如果一个变量是final，则必须赋初值，否则编译不了

3.当不希望类被继承时，可用final修饰 <final class xxx>

数组

一维数组

数组的必要性：

package com.test1;
public class Demo5_1{

   public static void main(String[] args){
    //定义六个变量
    //定义一个可以存放六个float类型的数组
    float arr[]=new float[6];
    //使用for循环赋值
    //给数组的各个元素赋值
    arr[0]=3;
    arr[1]=5;
    arr[2]=3.4f;
    arr[3]=2;
    arr[4]=50;

    //算总体重[遍历数组]
    float all=0;
    for(int i=0;i<6;i++)
    {
         all+=arr[i];
     }
      System.out.println("总体重是："+all);
   }
 }

对象数组的使用：

package com.test1;
import java.io.*;
public class Demo5_2{
   public static void main(String[] args){

   //定义一个可以存放四只狗的对象数组
   Dog dog[]=new Dog[4];

   //给各个狗赋初值

   //从控制台输入每个狗的信息[alt+j]快捷键
   InputStreamReader isr=new InputStreamReader(System.in);
   BufferedReader br=new BufferedReader(isr);
   for(int i=0;i<4;i++)
   {
      dog[i]=new Dog();
      System.out.println("请输入狗名");
      //从控制台读取狗名
      String name=br.readLine();
      //将名字赋给对象
       dogs[i].setName(name);
       System.out.println("");
       String s_weight=br.readLine();
       float weight=Float.parseFloat(s_weight);
       //将名字赋给对象
       dog[i].setWeight(weight);
    }
     //计算平均体重
     //计算总体重
     for(int i=0;i<4;i++)
    {
      allWeight+=dogs[i].getWeight();
     }
     //计算平均体重
     float avgWeight/dogs.length;
     System.out.println("总体重="+allWeight+"平均="+avgWeight)
   }
 }
//定义一个狗类
class Dog
{
    private String name;
    private float weight;
    public String getName(){
      return name;
    }
    public void setName(String name){
       this.name=name;
    }
    public float getWeight(){
       return weight;
    }
    public void setWeight(float weight){
       this.age=weight;
    }

}

排序分类：

1、内部排序：

（交换式排序法、选择式排序法、插入式排序法）

2、外部排序法：

（合并排序法、直接合并排序法）

交换式排序法：冒泡排序法、快速排序法

冒泡排序：

package com.test1;
public class Demo5_3{
   public static void main(String[] args){

   int arr[]={1,6,0,-1,9};
   //排序
   //外层循环，它决定一共走几趟
   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])
        {
           //换位
           temp=arr[j];
           arr[j]=arr[j+1];
           arr[j+1]=temp;
         }
   }
}
 //输出最后结果
   for(int i=0;i<arr.length;i++)
   {
      System.out.print(arr[i]+"");
   }

排序方法封装到类中：
class Bubble{

   //排序方法
   public void sort(int arr[])
   {
     int temp=0;
     for(int i=0;i<arr.length-1;i++)
     {
       for(arr[j]>arr[j+1])
       {
           temp=arr[j];
           arr[j]=arr[j+1];
           arr[j+1]=temp;
        }
     }
 }

调用：Bubble bubble=new Bubble();

bubble.sort(arr);

选择排序法:

class Select
{
   //选择排序
   public void sort(int arr[])
   {
     //默认第一个数最小

     for(int j=0;j<arr.length-1;j++)
     {
       int min=arr[j];
       //记录最小数下标
       int minIndxe=j;
       for(int k=j+1;k<arr.length;k++)
       {
          if(min>arr[k])
          {
            //修改最小
             min=arr[k];
             minIndxe=k;
            }
         }
}

插入式排序

将n个待排序的元素看成一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中有n-1个元素

class InsertSort
{
   //插入排序方法
   public void sort(int arr[])
   {
      for(int i=1;i<arr.length;i++)
      {
         int insertVal=arr[i];
         //insertVal准备和前一个数比较
         int index=i-1;
         while(index>=0&&insertVal<arr[index])

           //将arr[index]向后移动
           arr[index+1]=arr[index];
           //让index向前移动
           index--;
          }
           //将insertVal插入到适当位置
           arr[index+1]=insertVal;
    }
  }

多维数组

定义：

类型 数组名[][]=new 类型[大小][大小]

package com.test1;
public class Demo5_5{

    public static void main(String[] args)

    int a[][]=new int[4][6];

    a[1][2]=1;
    a[2][1]=2;
    a[2][3]=3;

    //将图形输出
    for(int i=0;i<4;i++)
    {
       for(int j=0;j<6;j++)
       {
         System.out.print(a[j]+"");
        }
        //换行
        System.out.println();

  }
 }

二进制（原码、反码、补码）：

1、二进制的最高位是符号位：0表示正数，1表示负数

2、正数的原码、反码、补码都一样

3、负数的反码=符号位不变，其他位取反

4、负数的补码=他的反码+1

5、0的反码、补码都是0

6、java没有无符号数

7、在计算机运算时候，都是以补码的方式来运算的

算数右移：地位溢出，符号位不变，并用符号位补溢出的高位

算数左移：符号位不变，低位补0

集合：

java集合类主要有以下几种：

1、List结构的集合类

ArrayList类，LinkedList类，Vector类，Stack类

2、Map结构的集合类

HashMap类，Hashtable类

3、Set结构的集合类

HashSet类，TreeSet类

4、Queue结构的集合

Queue接口

java集合的用法：

package com.test1;
import java.util.*;
public class Demo7{
   public static void main(String[] args){

   //定义ArrayList对象
   ArrayList a1=new ArrayList();
   //显示大小
   System.out.println("al大小："al.size());
   }
}