零基础学JAVA(基础知识)

一、环境变量配置

JAVA_HOME=C:\Program Files\Java\jdk1.8.0_111（你的jdk安装路径）

CLASSPATH=.;%JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar

PATH=;%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin

ps：变量名称不区分大小写

二、添加注释

单行注释：//     （Ctrl+/）

多行注释：/* */  （Ctrl+Shift+/）

三、断点调试

添加断点：鼠标双击左侧空白地方即可

F5——进入：移动到下一步骤，如果当前行有一个方法调用，改控件将会跳转到被调用方法的第一行执行。

F6——跳出：移动到下一行，如果在当前行有方法调用，那么会直接一定到下一行执行，不会进入被调用的方法体里面。

F7——返回：从当前方法中跳出，继续往下执行。

F8——移动到下一个断点出执行。

四、Eclipse设置智能提示

Window=>Preferences=>Java=>Editor=>Content Assist

右侧找到选项Auto activation triggers for java填写如下字符即可："ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba0123456789."

五、基本数据类型

Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

byte：

• byte 数据类型是8位、有符号的，以二进制补码表示的整数；
• 最小值是 -128（-2^7）；
• 最大值是 127（2^7-1）；
• 默认值是 0；
• byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
• 例子：byte a = 100，byte b = -50。

short：

• short 数据类型是 16 位、有符号的以二进制补码表示的整数
• 最小值是 -32768（-2^15）；
• 最大值是 32767（2^15 - 1）；
• Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
• 默认值是 0；
• 例子：short s = 1000，short r = -20000。

int：（Integer类型变量不赋值默认为null）

• int 数据类型是32位、有符号的以二进制补码表示的整数；
• 最小值是 -2,147,483,648（-2^31）；
• 最大值是 2,147,483,647（2^31 - 1）；
• 一般地整型变量默认为 int 类型；
• 默认值是 0 ；
• 例子：int a = 100000, int b = -200000。

long：

• long 数据类型是 64 位、有符号的以二进制补码表示的整数；
• 最小值是 -9,223,372,036,854,775,808（-2^63）；
• 最大值是 9,223,372,036,854,775,807（2^63 -1）；
• 这种类型主要使用在需要比较大整数的系统上；
• 默认值是 0L；
• 例子： long a = 100000L，Long b = -200000L。
  "L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。

float：

• float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
• float 在储存大型浮点数组的时候可节省内存空间；
• 默认值是 0.0f；
• 浮点数不能用来表示精确的值，如货币；
• 例子：float f1 = 234.5f。

double：

• double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数；
• 浮点数的默认类型为double类型；
• double类型同样不能表示精确的值，如货币；
• 默认值是 0.0d；
• 例子：double d1 = 123.4。

boolean：

• boolean数据类型表示一位的信息；
• 只有两个取值：true 和 false；
• 这种类型只作为一种标志来记录 true/false 情况；
• 默认值是 false；
• 例子：boolean one = true。

char：

• char类型是一个单一的 16 位 Unicode 字符；
• 最小值是 \u0000（即为0）；
• 最大值是 \uffff（即为65,535）；
• char 数据类型可以储存任何字符；
• 例子：char letter = 'A';。

六、建立键盘通往程序代码的桥梁

public static void main(String[] args) {
        // 建立键盘通向程序代码的桥梁
        Scanner input =new Scanner(System.in);
        System.out.println("请输入一个数字：");
        int a= input.nextInt();
        System.out.println("请再输入一个数字：");
        int b= input.nextInt();
        System.out.println("总数之和："+(a+b));
    }

 七、基础数据类型转换

public static void main(String[] args) {
        // TODO Auto-generated method stub
        int num=10;
        String str="123";
        
        // int类型转String
        String str1=Integer.toString(num);
        String str2=Integer.valueOf(num).toString();
        String str3=String.valueOf(num);
        // String类型转int
        int num1=Integer.parseInt(str);
        int num2=Integer.valueOf(str).intValue();
        System.out.print(str1);
    }

ps：其他数据类型的相互转换大同小异 

八、数组 

public static void main(String[] args) {
        
        // 声明与赋值方式一
        int[] arr1=new int[3];
        arr1[0]=1;
        arr1[1]=2;
        arr1[2]=3;
        
        // 声明与赋值方式二
        int[] arr2= new int[] {1,2,3};
        
        // 声明与赋值方式三
        int[] arr3={1,2,3};
        
        // 二维数组
        int[][] arrs= {{1,2,3},{4,5},{1,2,3,4,5,6}};
        int len1=arrs.length;     // 计算行的个数
        int len2=arrs[0].length;  // 计算第0行的列数
        
    }

ps: 多维数组声明方式也是一样

九、循环语句

public static void main(String[] args) {
        
        // 循环（while）
        //while(1==1)
        //{
            
        //}
        
        // 循环（do…while）
        //do {
            
        //} while (true);
        
        // 循环（for）方式一
        int[] arr= {1,2,3,4,5};
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("-------------");
        // 循环（for）方式二
        for(int i:arr)
        {
            System.out.println(i);
        }
        
    }

 十、类和对象

对象：对象是类的一个实例（对象不是找个女朋友），有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。

类：类是一个模板，它描述一类对象的行为和状态。

十一、成员变量和局部变量的区别

成员变量：某一个类的属性，同时被分为类变量（static）和实例变量（没有static）

局部变量：在方法中声明的变量

十二、继承（extends）

public class Home2 {
    
    public Home2() {
        
    }
    public Home2(String name) {
        this.name=name;
    }
    
    // 快捷操作（右键->Source=>Generate Getters and Setters）
    private String name; // 姓名
    private int age;     // 年龄
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

class Home3 extends Home2
{
    // 子类构造方法调用父类构造方法
    Home3()
    {
      super(); // 必须放在第一行代码中
    }
    Home3(String name)
    {
        super(name);
    }
    
}

 ps：子类默认调用父类的无参构造方法

 十三、多态(向上转型和向下转型)

public class Demo3 {
  public static void main(String[] args)
  {
      // 多态(向上转型)
      Animal p=new Dog();
      p.Sleep();  
      
      // 多态(向下转型)
      ((Dog)p).Behavior();
  }
}

abstract class Animal
{
    public  abstract void  Habit() ;
    public void  Sleep()
    {
        System.out.println("动物需要睡觉");
    }
}
class Dog extends Animal
{
    // 重写父类方法
    @Override
    public void Habit() 
    {
        
    }

    @Override
    public void Sleep() {
        System.out.println("狗狗需要睡觉");
    }
    
    public void Behavior() {
        System.out.println("动物都有自己的好习惯");
    }
}

 ps:同一事物具有多种形态

十四、JUnit（单元测试）

public class Home4 {
   
    @Test
    public void Test1() {
        System.out.println("测试一");
    }
    
    @Test
    public void Test2() {
        System.out.println("测试二");
    }
}

 ps导入架包：项目——Build Path——Configure Build Path——Java Build Path——Libraries——Add Library——JUnit

十五、instanceof关键字

    @Test
    public void Test3() {
        Integer i=10;
        boolean flag=(i instanceof Object);
        System.out.println(flag);
    }

作用：判断实例对象是否属于某个类型的实例，结果返回true和false

 十六、接口（interface）

interface A
{
    public void Test1();
    public abstract void Test2();
}

public class Home5 implements A {
    @Override
    public void Test1()
    {
        
    }
    @Override
    public void Test2() {
        
    }
}

 ps：类实现接口用关键字implements

十七、集合

List：（ArrayList、LinkedList）有序，可以有重复数据 

public static void main(String[] args) {
        
        // ArrayList
        ArrayList<Integer> arr=new ArrayList<Integer>();
        arr.add(123);
        // for循环
        for(int i=0;i<arr.size();i++)
        {
            System.out.println(arr.get(i));
        }
        
        // foreach循环
        for (Integer integer : arr) {
          System.out.println(integer);
        }
        
        // LinkedList
        LinkedList<Integer> list=new LinkedList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        // for循环
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        
        // foreach循环
        for (Integer integer : list) {
            System.out.println(integer);
        }
        
    }

 区别：1、ArrayList是实现了动态数组的数据结构；LinkedList基于链表的数据结构

           2、ArrayList查询（索引）数据的时候很快，但是增删很慢；LinkedList查询很慢，但是增删很快

 Set:（HashSet、TreeSet）无序，不可以有重复数据

HashSet:：低层结构是哈希表。往HashSet集合中存储元素的时候，有两个步骤：

                  1、找房间号，计算机中称之为哈希码，通过hashCode这个方法计算出来

                   2、与房间号中的每个数据进行比较，如果存在重复就不存储，如果不相同就存储，比较的时候是通过equest这个方法来比较的

public class Home7 {
    
@Test
public void test()
{
    UserInfo u1=new UserInfo();
    u1.setId(1);
    u1.setName("123");
    u1.setTel("123123");
    
    UserInfo u2=new UserInfo();
    u2.setId(1);
    u2.setName("123");
    u2.setTel("123123");
    
    HashSet<UserInfo> hSet=new HashSet<UserInfo>();
    hSet.add(u1);
    hSet.add(u2);
    
    for (UserInfo userInfo : hSet) {
        // 打印去掉重复数据(重写equals和hashCode方法)
        System.out.println(userInfo);
    }
}
}

class UserInfo {
    
    public int Id;
    public int getId() {
        return Id;
    }
    public void setId(int id) {
        Id = id;
    }
    public String Name;
    String Tel;
    public String getName() {
        return Name;
    }
    public void setName(String name) {
        Name = name;
    }
    public String getTel() {
        return Tel;
    }
    public void setTel(String tel) {
        Tel = tel;
    }
    
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + Id;
        result = prime * result + ((Name == null) ? 0 : Name.hashCode());
        result = prime * result + ((Tel == null) ? 0 : Tel.hashCode());
        return result;
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        UserInfo other = (UserInfo) obj;
        if (Id != other.Id)
            return false;
        if (Name == null) {
            if (other.Name != null)
                return false;
        } else if (!Name.equals(other.Name))
            return false;
        if (Tel == null) {
            if (other.Tel != null)
                return false;
        } else if (!Tel.equals(other.Tel))
            return false;
        return true;
    }
    
    @Override
    public String toString() {
        return "UserInfo [Id=" + Id + ", Name=" + Name + ", Tel=" + Tel + "]";
    }
}

 TreeSet：低层数据结构是二叉树。往TreeSet集合里面添加数据的时候，这个数据要有可比性，让Person继承Comparable这个接口，再实现这个方法(如下代码)。

public class Home8 {

    public static void main(String[] args) {
        
        Person p1=new Person();
        p1.setId(1);
        p1.setName("1112");
        
        Person p2=new Person();
        p2.setId(1);
        p2.setName("111");
        
        Person p3=new Person();
        p2.setId(2);
        p2.setName("222");
        
        TreeSet<Person> tSet=new TreeSet<Person>() 
        {
            {
                add(p1);
                add(p2);
                add(p3);
            }
        };
        
        for (Person person : tSet) {
            System.out.println(person);
        }

    }

}

class Person implements Comparable
{
    
    int Id;
    String Name;
    public int getId() {
        return Id;
    }
    public void setId(int id) {
        Id = id;
    }
    public String getName() {
        return Name;
    }
    public void setName(String name) {
        Name = name;
    }
    
    @Override
    public String toString() {
        return "Person [Id=" + Id + ", Name=" + Name + "]";
    }
    
    @Override
    public int compareTo(Object o) {
        Person p=(Person)o;
        if(p.Id==this.Id)
        {
            return p.Id;
        }
        return this.Id;
    }
}