JAVA基础学习笔记

 类和对象
·定义类

 [修饰符]class <类名>[extends 父类名][implement 接口列表]{
  定义成员变量;
  定义成员方法;
 }

 
 修饰符：可选，public/abstract/final
 类名：必选 一般要求首字母大写
 extends 父类名：可选，用于指定继承哪个父类
 implements 接口列表：可选，用于指定该类实现了那些接口
 ★类文件的名称必须与类名相同
·类的成员方法由方法的声明和方法体两部分组成

 [修饰符] <方法返回值的类型><方法名>([参数列表]){
  [方法体]
}

 
·成员变量和局部变量
  ☆在类体中变量定义部分所声明的变量为类的成员变量

 [修饰符]class <类名>[extends 父类名][implement 接口列表]{
  定义成员变量;
  定义成员方法;
 }

 
 修饰符：可选，public/protected/private
 final :可选，用于指定该成员变量为不会改变的常量
 transient：可选，暂时性变量，用于对象存盘
 volatile：共享变量，用于并发线程的共享
  ☆在方法体中声明的变量和方法的参数为局部变量
 [final]<变量类型><变量名>
 final：可选，用于指定该局部变量为常量
★当局部变量和成员变量相同时，成员变量会被隐藏，如果使用成员变量，必须使用关键词this
·构造方法
 只是一种特殊的方法，名字与类名相同，没有返回值，也不用void修饰，用于对对象中所有成员变量进行初始化，在创建对象时就会被调用。
 ★如果用户没有定义构造方法，则java会自动提供一个默认的构造方法。
例子：

public class Fruit {

 public String color;
 public Fruit(){
  color="绿色";
 }
 public void harvest() {
  String color="红色";
  System.out.println("水果是："+color);
  System.out.println("水果已经收获……");
  System.out.println("水果原来是："+this.color+"的");
  
 }
 public static void main(String[] args) {
  Fruit fruit = new Fruit();
  fruit.harvest();

 }

}

 

——————————————————————————————————
·创建包
 package 包名;
  当包中还包含包的时候，可以使用“包1.包2.…….包n”进行指定。
  ★在java中提供的包相当于系统中的文件夹。例如， package com.wgh中有一个Demo类的话，那么他的实际路径相当于 com/wgh/Demo.java
·使用包中的类
 1、使用长引用包中的类
  只需在类名前面加上完整的包名即可
  com.wgh.Demo circ= new com.wgh.Demo
 2、使用import语句引入包中的类
  格式：import 包名1.包名2.…….包名n.类名|*；
  ★当存在多个包名的时候，包名之间使用.隔开，同时包名和类名  之间也用.隔开，*代表包中所有的类
  ☆引入一个类的时候：import com.wgh.Demo;
  ☆如果引入多个类：import com.wgh.*；表示引入这个包中所有  的类。
--------------------------------------------------------------------
    继承
·子类对象的创建
 可以使用extends来指名其父类，格式如下

 [修饰符]class 类名 extends 父类名

 
 [修饰符]可选：public、abstract、final
 [类名]必选：必须是合法的java标识符。
 [父类名]：必选：指定定义的子类继承于哪个父类
 ☆例子
 abstract class Cattle extends Animal{
  ……
 }
 ★子类能够继承父类中声明为public和protected的成员变量和方法，但是不能继承private的成员变量和方法；
 ★如果子类中声明了一个与父类的成员变量/成员方法同名的成员变量，则子类不能继承父类的成员变量/成员方法。此时，此时称子类的成员变量/方法隐藏/覆盖了父类的成员变量/方法。

 ☆例子
 1、创建Animal类

public class Animal {

 public boolean live = true;
 public String skin="";
 public void eat() {
  System.out.println("动物会吃食物的");
  
 }
 public void move() {
  System.out.println("动物都会动");
 }

}

 

2、创建子类Bird

public class Bird extends Animal{
 public String skin = "羽毛";
 public void move() {
  System.out.println("鸟是会飞的");
 }
}

 
3、创建zoo类，在其中，创建Bird的对象，并分配内存，调用该类的成员方法，以及成员变量。
 

public class Zoo {

 public static void main(String[] args) {
  Bird bird =new Bird();
  bird.eat();
  bird.move();
  System.out.println("鸟是："+bird.skin);

 }

}

 

运行结果：
动物会吃食物的
鸟是会飞的
鸟是：羽毛

★super关键字
 1、调用父类的构造方法
 super ([参数列表]);
 [参数列表]如果父类的构造方法中包括参数，则为必选。
 ☆例
 ①在Animal类中添加一个默认的构造方法，和一个带参数构造方法

 public Animal(){
 }
 public Animal(String strSkin){
  skin = strSkin;
 }

 
 ②如果要在子类Bird中使用父类的带参数的构造方法

 Public Bird(){
  super("羽毛");
 }

 
 2、操作被隐藏的成员变量和被覆盖的成员方法
 在子类中操作父类中被隐藏的成员变量和被覆盖的成员方法。
 super.成员变量名
 super.成员方法名（[参数列表]）
 ☆例

 super.skin="羽毛";
 super.move();

 
—————————————————————————————————
多态
·方法的重载
 方法的重载是指在一个类中，出现多个方法名相同，但是参数个数或者参数类型不同的方法，则称为方法的重载。
 ☆例：

public class Calculate {
 final float PI=3.14159f;
 //求圆形的面积
 public float getArea(float r){
  float area=PI*r*r;
  return area;
 }
 //求矩形的面积
 public float getArea(float l,float w) {
  float area = l*w;
  return area;
 }
 //画任意形状的图形
 public void draw(int num) {
  System.out.println("画"+num+"个任意图形的形状");
 }
 public void draw(String shape) {
  System.out.println("画一个"+shape);
 }
 public static void main(String[] args) {
  Calculate calculate = new Calculate();
  float l = 20;
  float w = 30;
  float areaRectagle=calculate.getArea(l, w);
  System.out.println("求长为"+l+"宽为"+w+"的矩形面积是"+areaRectagle);
  float r = 7;
  float areaCirc = calculate.getArea(r);
  System.out.println("求半径为"+r+"的圆形的面积是："+areaCirc);
  int num = 7;
  calculate.draw(num);
  calculate.draw("三角形");
  
 }

}

 
·方法的覆盖
 覆盖是父子类之间的关系，子类继承父类的方法名与父类的方法名相同时候，子类就不能继承父类的方法，子类的方法覆盖了父类的方法。通过覆盖，可以使一个方法在不同的子类中表现出不同的行为。
 ★子类不能覆盖父类中声明为final或者static的方法
 ★子类必须覆盖父类中声明为abstract的方法，或者子类也应该声明为abstract
 ★子类覆盖父类中的同名方法时，子类的方法声明也必须和父类中被覆盖的方法声明一样。
-------------------------------------------------------------------
抽象类与final类
 抽象类
只声明方法的存在而不去具体实现他。抽象类不能被实例化，也就是不能创建其对象。在定义抽象类的时候，要在关键字class前面加上abstract。
 格式
 abstract class 类名{
  类体
 }
在抽象类中创建的，没有实际意义的，必须要重写的方法叫做抽象方法。抽象方法只有方法的声明，而没有方法的实现。用关键字abstract进行修饰。
 格式：

 abstract <方法返回值类型> 方法名 (参数列表)；

 
 ★抽象方法不能使用private和static关键字进行修饰

abstract class Instrument {
 abstract void play();

}

class piano extends Instrument {
 public void play() {
  System.out.println("钢琴演奏");
 }
}

class cello extends Instrument {
 public void play() {
  System.out.println("大提琴演奏");
 }
}

class violin extends Instrument {
 public void play() {
  System.out.println("小提琴演奏");
 }

}

class testplay1 {

 public void testplay(Instrument obj) {
  obj.play();
 }
}
public class InstrumentTest {

 public static void main(String[] args) {

  Instrument piano1 = new piano(); //抽象类不能创建对象
  Instrument violIn1 = new violin();
  Instrument cello1 = new cello();
  testplay1 test = new testplay1();
  test.testplay(cello1);
  test.testplay(violIn1);
  test.testplay(piano1);

 }

}

 

★抽象方法不能使用private或者static关键字进行修饰
包含一个或者多个抽象方法的类必须被声明为抽象类。
·final类
改类不能被继承，即不能有子类。
final class 类名{
 类体
}

——————————————————————————————————
接口
java一个类只能有一个父类。
使用interface来定义一个接口。接口的定义分为接口的声明和接口体
 格式

 [修饰符]interface 接口名 [extends 父接口名列表]{
  [pbulic][static][final]常量;
  [public][sbstract] 方法;
 }

 
★接口中的方法只有定义，没有被实现
☆接口文件的文件名必须与接口名相同。

实现接口
可以在类中实现接口，在类中实现接口，可以使用implements，格式如下

[修饰符]class <类名>[extends 父类名] [imlements 接口列表]{
 
}

 
★在类中实现接口时，方法的名字、返回值类型、参数的个数及类型，必须与接口中的完全一致，并且实现接口中的所有的方法。（抽象类不需要实现接口中的所有的方法）

例子：

public interface Calculate {
 float getArea(float r);
 float getCir(float r);
}

import java.util.Scanner;

public class Cire implements Calculate {
 final float PI = 3.14159f;

 public float getArea(float r) {
  float area = PI * r * r;
  return area;
 }

 public float getCir(float r) {
  float cir = 2 * PI * r;
  return cir;

 }

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Cire yuanCire = new Cire();
  System.out.println("请输入一个半径");
  Scanner cinScanner= new Scanner(System.in);
  float r = cinScanner.nextFloat();
  float area = yuanCire.getArea(r);
  float cir =yuanCire.getCir(r);
  System.out.println("圆的面积是"+area);
  System.out.println("圆的周长是"+cir);
 }

}

 

--------------------------------------------------------------------
    数组
声明一维数组：
 

int arry[ ]=new int[ 6];
 int arry1[ ] = {1,2,3,4};

 
实例：

import java.util.Random; //random类


public class ArrayNew {

 /**
  * @param args
  */
 public static void main(String[] args) {
  Random random = new Random();
  int [] a = new int [random.nextInt(20)];/*随机产生0~20的整数值。*/
  double []b= new double [random.nextInt(20)];
  System.out.println("a"+a.length);
  System.out.println("b"+b.length);
  for(int i=0;i<a.length;i++)//a.length获取数据的长度
  {
   a[i]=random.nextInt(20);
   System.out.println("a["+i+"]的值是"+a[i]);
  }
  for(int i=0;i<b.length;i++){
   b[i]=random.nextInt(10);
   System.out.println("b["+i+"]的值是:"+b[i]);
  }
  // TODO Auto-generated method stub

 }

}

 

例二：

public class Arraysize {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Overarray [] arrayOverarray=new Overarray[6];
  int [] Array1 = new int[5];
  double []Array2 = new double[6];
  for(int i=0;i<Array1.length;i++)
  {
   Array1[i]=i;
   arrayOverarray[i]=new Overarray(Array1[i]);
   
  }
  for(int i=0;i<Array2.length;i++){
   Array2[i]=Math.tan(i);
   arrayOverarray[i]=new Overarray(Array2[i]);
  }
 }

}


public class Overarray {
 public Overarray(int i){
  System.out.println("int 类型数组"+i);
 }
 public Overarray (Double i){
  System.out.println("double类型的数组"+i);
 }
}

 

·二维数组
 定义：int [][]array=new int [2][3];
 初始化：array = new int []...[]{1,2,3,,4……};
 或者：array =  new int []…[]{new 构造方法（参数列）,new 构造方法（参数列）,……};
 
·使用二维数组
 二维数组求最小值
 

public class MutiArray {
//定义一个二维数组
 int grades[][]={
   {77,68,76,5},
   {32,45,65,67},
   {34,45,56,69}
 };
 //求数组中的最小值，使用循环
 public int minimum() {
  int lowGrade=grades[0][0];
  //二维数组中，数组名.length的意思是，有多少行，行名.length是那一行有多少列。
  for(int row=0;row<grades.length;row++){
   for(int cloumn=0;cloumn<grades[row].length;cloumn++){
    if(grades[row][cloumn]<lowGrade)
     lowGrade=grades[row][cloumn];
    
   }
  }
  return lowGrade;
  
 }
 public static void main(String[] args) {
  MutiArray m=new MutiArray();
  System.out.println("最小的数字是："+m.minimum());
  // TODO Auto-generated method stub

 }

}

 

打印三维数组
 

public class Treewei {

 /**
  * @param args
  */
 public static void main(String[] args) {
  int[][][] a = new int[1][2][3]; 
  for(int i=0; i<a.length; i++){   
   for(int j=0; i<a[i].length; j++){      
    for(int k=0; k<a[i][j].length; k++)            
     System.out.println(a[i][j][k]);    
    } 
   }

 }

}

 

数组的操作
复制数组：
 语法：System.arraycopy(Array1,0,array2,0,length);
 Array1是源拷贝数组
 Array2是目标数组

public class Arraycopy {

 public static void main(String[] args) {
  int []array ={1,5,4,3,2,5,33,23,24,24};
  int []array2 = new int [10];
//  将array拷贝到array2中去
  System.arraycopy(array, 0, array2, 0, array.length);
//  简单的遍历方法
  for (int i:array2)
   System.out.println("arrar2："+i);

 }

}

 

数组排序：
 Arrays类提供的几个方法：
sort（） 快速排序（从小到大）
bingarySearch（）对已经排好序的数组进行二叉树搜索，如果搜索到结果，则返回索引值，否则返回负值
fill（） 填充数组
equals（） 比较数组中的数是否相等。是返回true，否返回false。

 public static void main(String[] args) {
  String [] s=new String[]{"abc","deede","Hello","asdkj","12"};
  String [] s2=new String[5];
  //复制一个数组。
  System.arraycopy(s, 0, s2, 0, s.length);
//  对数组快速排序
  Arrays.sort(s);
  //从数组中找到一个元素，从0开始计数
  System.out.println(Arrays.binarySearch(s, "asdkj"));
  //对数组进行快速排序
  System.out.println(Arrays.asList(s));
  //对数组忽略大小写排序
  
  
 }

}

 

import java.util.Arrays;


public class arrayfill {
 public static void main(String[] args) {
  int []a1=new int[5];
  //使用填充数组，进行填充数组内的数字
  Arrays.fill(a1, 111);
  for(int i:a1)
   System.out.println("数组是"+i);

 }

}

 

————————————————————————————————
字符串
声明字符串变量
String str [];
字符串的比较：
1.equal（）方法和equalslgnoreCase（）方法
·equal（）方法
 String用于比较两个字符串是否相等，使用的是比较两个字符串是否相等，不能用==号来比较。比较的是内容，区分字符大小写。==号比较的是内存地址。