Java学习总结1

1. 断点调试
 a：定位（设置断点）
 b：启动调试
 c：单步执行  观察变量（F5单步执行   F6单步跳过）
d：修改
2 static  静态
  静态成员，为类的所有对象共享
  在静态方法中，只能直接调用静态成员，不能直接调用非静态成员
  在成员方法中，可以直接调用静态成员与非静态成员
  静态成员的调用： 类名打点方式调用
3 方法重载：
  在一个类中有两个及两个以上的方法名相同，参数列表不同（参数类型   参数个数）
4 构造器 ：  对象的初始化
 特点： 构造器的名称必须与类名相同；  无返回值 无返回类型
 默认情况下，类中有一个无参构造方法
 待我们写出有  有参构造器，系统默认的无参构造器不再生成  。if......we need .....
5 在构造器中使用this
在构造器中调用其他构造器
  this（）；      （this语句必须是本构造器的第一句）

方法摘要
1  char
    charAt(int index)

           返回指定索引处的 char 值。
               index - char 值的索引。
2 string
       concat(String str)
          将指定字符串连接到此字符串的结尾。
                 str - 连接到此 String 结尾的 String。

        substring(int beginIndex)
          返回一个新的字符串，它是此字符串的一个子字符串。
            beginIndex - 起始索引（包括）。
3  boolean
        endsWith(String suffix)
          测试此字符串是否以指定的后缀结束。
              suffix - 后缀。

        startsWith(String prefix)
          测试此字符串是否以指定的前缀开始。
 
       equals(Object anObject)
          将此字符串与指定的对象比较。
         anObject - 与此 String 进行比较的对象

        equalsIgnoreCase(String anotherString)
          将此 String 与另一个 String 比较，不考虑大小写。
          anotherString - 与此 String 进行比较的 String。

4 int
       indexOf(int ch)
          返回指定字符在此字符串中第一次出现处的索引。
             ch - 一个字符

        indexOf(int ch, int fromIndex)
          返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
          ch - 一个字符   fromIndex - 开始搜索的索引。

        indexOf(String str)
          返回指定子字符串在此字符串中第一次出现处的索引。
         str-任意字符串

        indexOf(String str, int fromIndex)
          返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
          str - 要搜索的子字符串。fromIndex - 开始搜索的索引位置。
     public int lastIndexOf(int ch)
    public int lastIndexOf(iint ch, int fromIndex)  
    public int lastIndexOf(String str)
    public int lastIndexOf(String str, int fromIndex)    

     length()
          返回此字符串的长度。

方法调用栈

所有的方法都维护在一个称为调用栈的结构中，当前正在执行的方法位于调用栈。

对于基本类型的变量：java虚拟机将其放在栈中。

对于引用类型的变量：引用变量本身放在栈中，而引用所指向的对象是放在java堆中。引用不包含它所指向的对象的实际数据，而是指向内存中对象所在的位置。

如果一个变量是引用类型的，那么变量的值就是一个内存地址，这个内存地址是引用指向的对象的位置。
按值调用

 
指的是在方法调用时，传递的参数是按值的拷贝传递。

示例如下：

public class TempTest {

private void test1(int a){

//做点事情

}

public static void main(String[] args) {

TempTest t = new TempTest();

int a = 3;

t.test1(a);//这里传递的参数a就是按值传递

}

}

按值传递重要特点：传递的是值的拷贝，也就是说传递后就互不相关了。

示例如下：

public class TempTest {

private void test1(int a){

a = 5;

System.out.println("test1方法中的a==="+a);

}

public static void main(String[] args) {

TempTest t = new TempTest();

int a = 3;

t.test1(a);//传递后，test1方法对变量值的改变不影响这里的a

System.out.println("main方法中的a==="+a);

}

}

运行结果是： test1方法中的a===5

　　　　　　main 方法中的 a===3


3.2：按引用传递是什么 指的是在方法调用时，传递的参数是按引用进行传递，其实传递的引用的地址，也就是 变量所对应的内存空间的地址。

3.3：按引用传递的重要特点 传递的是值的引用，也就是说传递前和传递后都指向同一个引用（也就是同一个内存 空间）。

示例如下： 第1行 public class TempTest {

 private void test1(A a){

a.age = 20;

System.out.println("test1方法中的age="+a.age);

}

public static void main(String[] args) {

 TempTest t = new TempTest();

 A a = new A();

a.age = 10;

 t.test1(a);

 System.out.println("main方法中的age="+a.age);

 }
}
class A{
 public int age = 0;

}

运行结果如下： test1方法中的age=20

　　　　　　　　main 方法中的 age=20

（1）： “在 Java 里面参数传递都是按值传递”这句话的意思是：按值传递是传递的值的 拷贝，按引用传递其实传递的是引用的地址值，所以统称按值传递。

（2）：在 Java 里面只有基本类型和按照下面这种定义方式的 String 是按值传递，其它 的都是按引用传递。就是直接使用双引号定义字符串方式：String str = “Java 私塾”;   

方法的重载

当一个类有两到多个同名 但是有不同的参数列表的方法。
重载示例 如下例所示：

void getArea(int w,int h);

void getArea(float w,float h);

在第二种情况下，成员方法 getArea()接受两个浮点变量作为它的参数，编译器根据调 用时的不同参数来决定该调用哪一种成员方法，假如你把两个整数提供给成员方法，就 调 用 第 一个成员方法；假如你把两个浮点数提供给成员方法，第二个成员方法就被调用。 当写代码来调用这些方法中的一个方法时，便以其会根据提供的参数的类型来选择合适 的方法。
注意：跟成员方法一样，构造方法也可以重载。
2.2：方法的重载的规则
（1）：方法名称必须相同

（2）：参数列表必须不同（个数不同，或类型不同，或参数排列顺序不同） 。

（3）：方法的返回类型可以相同也可以不相同。仅仅返回类型不同不足以成为方法的重 载。
数组

数组是由相同类型的若干项数据组成的一个数据集合。也就是说数组是用来集合相同类 型的对象并通过一个名称来引用这个集合，数组是引用类型。

声明方法：

声明一:  int x[];

声明二：int [] x=new int[3];

声明三：int[]x=new int[]{3,4,5};

数组复制的方法是使用System类提供的arraycopy()方法，其语法如下：
System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length);
System.arraycopy(源数组，源数组中的起始位置，目标数组，目标数据中的起始位置，要复制的数组元素的数量);
public class T {
       public static void main(String args[]){
              int arr1[] = {1,2,3,4,5};
              int arr2[] = new int[5];
              System.arraycopy(arr1, 0, arr2, 0, 5);

              for (int i = 0; i < arr2.length; i++) {
                    System.out.println(arr2[i]);
              }
       }
}
Arrays类
对数组的一些基本操作，像排序、搜索与比较等都是很常见的。在java中提供了Array是类可以协助您作这几个操作，Array是类位于java.util包中，他提供了几个方法可以直接使用。

sort()                       帮助您对指定的数组排序，所使用的是快速排序法

 
binarySearch()      让您对已排序的数组进行二元搜索，如果找到指定的值就返回该值所在的索引，否则就返回负值

fill()                           当您配置一个数组之后，会依据数据类型来给定默认值。例如整数数组就初始值为0，可以使用Arrays.fill()方法将所有的元素设置为指定的值

equals()                   比较两个数组中的元素值是否全部相等，如果是将返回true，否则返回false

继承

public class Employee {  

String name;

  Date hireDate;  

Date dateOfBirth;  

String jobTitle;   int grade;  

... }

public class Manager extends Employee {  

String department;  

Employee[] subordinates;  

... }

在这样的定义中，Manager 类被定义，具有 Employee 所拥有的所有变量及方法。所有 这些变量和方法都是从父类的定义中继承来的。

关键字是extends.

在 Java 编程语言中，对象的初始化是非常结构化的，这样做是为了保证安全。在前面 的模块中，看到了当一个特定对象被创建时发生了什么。由于继承性，对象被完成，而且下 述行为按顺序发生：

（1）存储空间被分配并初始化到 0 值    

（2）进行显式初始化    

（3）调用构造方法

关键字 super

关键字 super 可被用来引用该类的父类，它被用来引用父类的成员变量或方法。父类行 为被调用，就好象该行为是本类的行为一样，而且调用行为不必发生在父类中，它能自动向 上层类追溯。
super 关键字的功能：

（1）：点取父类中被子类隐藏了的数据成员

（2）：点取已经覆盖了的方法

（3）：作为方法名表示父类构造方法

例如：

public class Employee {

private String name;

private int salary;

public String getDetails() {

return "Name: " + name + "\nSalary: " + salary; }

}

public class Manager extends Employee {

private String department;
public String getDetails() {

return super.getDetails() + // 调用父类的方法 "\nDepartment: " + department;

}

}

构造方法不能被继承                                                              

 尽管一个子类从父类继承所有的方法和变量，但 它不继承构造方法，掌握这一点很重要。 一个类能得到构造方法，只有两个办法。或者写构造方法，或者根本没有写构造方法， 类有一个默认的构造方法。

调用父类构造方法

在许多情况下，使用默认构造方法来对父类对象进行初始化。 当然也可以使用 super 来显示调用父类的构造方法。
public class Employee {

String name;

public Employee(String n) {

name = n;

}

}
public class Manager extends Employee {

String department;

public Manager(String s, String d) {

super(s);

department = d;

}

}

注意：无论是 super 还是 this，都必须放在构造方法的第一行。

单继承性                         

单继承性：当一个类从一个唯一的类继承时，被称做单继承性。单继承性使代码更可靠。 接口提供多继承性的好处，而且没有（多继承的）缺点。 Java 编程语言允许一个类仅能继承一个其它类，即一个类只能有一个父类。这个限制 被称做单继承性。单继承性与多继承性的优点是面向对象程序员之间广泛讨论的话题。Java 编程语言加强了单继承性限制而使代码更为可靠，尽管这样有时会增加程序员的工作。后面 会学到一个被叫做接口（interface）的语言特征，它允许多继承性的大部分好处，而不受 其缺点的影响。

调试断点debug    

　　1、定位逻辑错误（设置断点）    

　　2、启动调试    

　　3、单步执行，观察变量    

　　4、修改

 null与" "是有区别的，后者分配了空间

调用方法  

当一个方法正在执行时，有三种情况  

　　1、方法返回一个值  

　　2、方法不反回一个值  

　　3、方法抛出一个异常给调用者（以后专门讨论）

方法签名  

　　方法签名包括访问修饰符、可选修饰符、  方法名、参数列表、返回值的数据类型等信息  

　　例如：   public static double random()

访问修饰符

　　 public、private、protected

可选修饰符  

　　static、final、abstract、native、synchronized.  

　　用static修饰的方法为静态成员，为类的所有对象共享  

　　在静态方法中，只能够直接调用静态成员，不能直接调用非静态成员     

　　静态成员的调用，通过类名打点的方式调用  

　　在成员方法中（未被static修饰的方法），可以直接调用静态成员与非静态成员  

　　形式参数与实际参数 按值调用 方法重载（真他妈机智的方式，也叫做静态的多态）  

　　当一个类有两到多个同名但是有不同参数列表的方法时，就是方法重载。  

　　重载一个方法，只要方法的形式参数列表对编译器来说是截然不同时，就会方法重载。  

　　与参数的类型相关，与名字无关。  

　　例如：getDay(int year)与getDay(int day)不是方法重载   

　　而println()中如果输入不同的参数就可以调用不同的方法

　　 构造器  Person someOne = new Person();

　　 注意：构造方法的名字必须和类名一致，构造方法没有返回类型       

　　默认情况下，类中有一个无参构造方法       

　　例如：public Person( ){

   　　}       

　　并且我们可以在这个构造方法中初始化数据。      
　　除此之外，我们可以创建一个含参数的构造方法。      
　　注意：如果我们写出了有参构造器时，系统不会再产生无参构造器，如果要使用，必须自己重新再写。 
　　构造器是一个特殊的方法，它在类创建一个实例时被调用执行。 
　　构造器的目的是初始化类的实例，使其成为一个有效的状态。 
　　只要是一个对象被创建，构造器中再调用同一个类中其他的构造器，用到this语句 （必须要是构造语句中的第一句）。 
　　例如：   public Person(int stuNum,char name){
 　　 }  
　　　　　　public Person(int stuNum,char name，String age){    

　　　　　　　　this(stuNum,name);   

　　　　　　}
比较字符串的大小 
　　忽略大小写.equalsIgnoreCase( );