java初始基本

一、概述

Java实例分析

public class BankAccout {
    private double balance;
//构造函数   
   public BankAccout(double openingBalance){
        balance=openingBalance;
    }
    public void deposit (double amount){
        balance=balance+amount;
    }
    public void withdraw(double amount){
        balance=balance-amount;
    }
    public void display(){
        System.out.println("balance="+balance);

    }
}




public class BankApp {

    public static void main(String[] args) {
      BankAccout ba1=new BankAccout(100.00);
      System.out.print("Before transaction,");
      ba1.display();
      ba1.deposit(74.35);
      ba1.withdraw(20.00);
      System.out.print("After transactions");
      ba1.display();
    }
}

Java类的定义：自认为是一个总的大体设计，比如想要造一个车，此时的车就是一个类

Java对象：包含于类中的具有某些功能的函数，比如上面的void deposit (double amount){}就是一个对象，在主函数中比如ba1.deposit(74.35);等等都是对如一个对象的使用-------》》》又叫做实例化对象。

Java继承：就是我拿你的东西用，我就不做了嘛；比如我创建了一个ui窗口（父类），那么在我创建按钮的类中我就可以把原先的写好的JFrame拿过来用就行了 ，比如随便写一个, 意思就是我在面板/窗口可以创建属于我自己的按钮等等。

class Button extends JFrame{
..........
}

class 父类 {
}
 
class 子类 extends 父类 {
}

Java多态：

多态是同一个行为具有多个不同表现形式或形态的能力。

多态性是对象多种表现形式的体现。

比如我们说"宠物"这个对象，它就有很多不同的表达或实现，比如有小猫、小狗、蜥蜴等等。那么我到宠物店说"请给我一只宠物"，服务员给我小猫、小狗或者蜥蜴都可以，我们就说"宠物"这个对象就具备多态性。

接下来让我们通过实例来了解Java的多态。

例子

public interface Vegetarian{}
public class Animal{}
public class Deer extends Animal implements Vegetarian{}

因为Deer类具有多重继承，所以它具有多态性。以上实例解析如下：

• 一个 Deer IS-A（是一个） Animal
• 一个 Deer IS-A（是一个） Vegetarian
• 一个 Deer IS-A（是一个） Deer
• 一个 Deer IS-A（是一个）Object

当我们将引用型变量应用于Deer对象的引用时，下面的声明是合法的：

Deer d = new Deer();
Animal a = d;
Vegetarian v = d;
Object o = d;

所有的引用型变量d,a,v,o都指向堆中相同的Deer对象。

引用：比如上面的  Vegetarian v，就是一个类的引用。与int es 这种定义并不同的是es原本就是赋值了的。而v则是储存了Vegetarian这个对象的一个地址。

 

new操作符：Java中创建对象必须要用new，不像c++中返回的是一个指针，它返回的是一个引用。

关系操作符==：

carpart str1=new carpart("fenser");
carpart str2=str1;
if(str1==str2){
    return "str1 and str2 equal";
}

      其中的==在Java中实际上判断的是类的引用是否一致。但在C++中是判断数据是否相同，在Java中如果要用数据相同则必须要用到equals（）类

carpart str1=new carpart("fenser");
carpart str2=str1;
if(str1.equals(str2)){
    return "str1 and str2 equal";
}

二、数组

Java中，把数组当对象使用。

//数组的创建
int[] array;
array=new int[10];
//或者合并方式
int array[]=new int [10];

//附录：：：：：
//随机数生成
import java.util.Random; 
public class Test06
{
    public static void main(String[] args)
    {
        Random r=new Random();
        double d1=r.nextDouble();    //生成[0,1.0]区间的小数
        double d2=r.nextDouble()*7;    //生成[0,7.0]区间的小数
        int i1=r.nextInt(10);    //生成[0,10]区间的整数
        int i2=r.nextInt(18)-3;    //生成[-3,15]区间的整数
        long l1=r.nextLong();    //生成一个随机长整型值
        boolean b1=r.nextBoolean();    //生成一个随机布尔型值
        float f1=r.nextFloat{);    //生成一个随机浮点型值
        System.out.println("生成的[0,1.0]区间的小数是："+d1);
        System.out.println("生成的[0,7.0]区间的小数是："+d2);
        System.out.println("生成的[0,10]区间的整数是："+il);
        System.out.println("生成的[-3,15]区间的整数是："+i2);
        System.out.println("生成一个随机长整型值："+l1);
        System.out.println("生成一个随机布尔型值："+b1);
        System.out.println("生成一个随机浮点型值："+fl);
        System.out.print("下期七星彩开奖号码预测：”）；
        for(int i=1;i<8;i++)
        {
            int num=r.nextlnt(9);    //生成[0,9]区间的整数
            System.out.print(num);
        }
    }
}

数组应用实例

import java.util.Random;
public class arrayApp {
    public static void main(String[] args){
        long [] arr;
        arr=new long [100];
        int nElems=0;
        int j;
        long searchkey;
        Random r=new Random();
        for(int i=0;i<arr.length;i++){
            arr[i]=r.nextInt(18)-3;
        }
        nElems=10;
        for(j=0;j<nElems;j++){
            System.out.print(arr[j]+" ");
        }
        //寻找66
        searchkey=66;
        for(j=0;j<nElems;j++)
            if(arr[j]==searchkey)
                break;
            if(j==nElems)
                System.out.println("Can't find" +searchkey);
            else
                System.out.println("Find" +searchkey);
            //删除0
        searchkey=0;
        for(j=0;j<nElems;j++)
            if(arr[j]==searchkey)
                break;
        for (int k=j;k<nElems;k++)
            arr[k]=arr[k+1];
        nElems--;
        for(j=0;j<nElems;j++){
            System.out.print(arr[j]+" ");
        }


    }
}

Java封装，我想可以把上面的数组封装在一个类中实现对一个数组的调用就行了；

//封装类
public class LowArray {
    private long [] a;
    public LowArray(int size){
        a=new long [size];
    }
    //向数组中添加元素
    public void setElem(int index,long value){
        a[index]=value;
    }
    public long getElem(int index){
        return a[index];
    }
}

//主类简单实现查找
import java.util.Random;
public class LowerArrayapp {
    public static void main(String [] args){
            LowArray arr;
            arr=new LowArray(100);
            int nElem=0;
            int j;
            Random r=new Random();
            for(j=0;j<10;j++){
                int temp=r.nextInt(18);
                arr.setElem(j,temp);
                System.out.println(arr.getElem(j)+"  ");
            }


            int searchKey=r.nextInt(18);
            nElem=10;
            for(j=0;j<nElem;j++)
                if(arr.getElem(j)==searchKey)
                    break;
                if (j==nElem)
                    System.out.println("Can't find " +searchKey);
                 else
                     System.out.println("Find " +searchKey);
    }
}

不过呢，在上面的程序中都是通过下标来寻找数，为了简单，我们创建新的接口类来访问数据，这样的话主类就更加的简单了。

//新的封装类
public class HighArray {
    private long[] a;
    private int nElems;

    public HighArray(int Max){
        a=new long[Max];
        nElems=0;
    }

    public boolean find(long searchKey){
        int j;
        for(j=0;j<nElems;j++)
            if(a[j]==searchKey)
                break;
        if(j==nElems)
            return false;
        else
            return true;
    }
    public void insert(long value){
        a[nElems]=value;
        nElems++;
    }
    public boolean delete(long value){
        int j;
        for(j=0;j<nElems;j++)
            if(value==a[j])
                break;
        if(j==nElems)
            return false;
        else {
            for (int k=j;k<nElems;k++)
                a[k]=a[k+1];
            nElems--;
            return true;
        }
    }

    public void display(){
        for(int j=0;j<nElems;j++)
            System.out.println(a[j]+"  ");
        System.out.println("");
    }
}
//主类
import java.util.Random;
public class HighArrayApp {
    public static void main(String[] args){
        int maxSize=100;
        HighArray arr;
        Random r=new Random();
        arr=new HighArray(maxSize);
        int i;
        for(i=0;i<10;i++){

            int temp=r.nextInt(18);
            arr.insert(temp);
        }
        arr.display();

        int searchKey=r.nextInt(18);
        System.out.println("需要查找的数是：："+searchKey);
        if(arr.find(searchKey))
            System.out.println("Find " +searchKey);
        else
            System.out.println("can't Find " +searchKey);

        arr.delete(12);
        arr.delete(55);

        arr.display();

    }
}