【Java】Day1-基础基础

Part1

一.Java基础介绍

• Java是一门后台开发语言，使用的是大型Web系统开发，APP后台服务器首选开发语言。
• Java语言特点：跨平台，安全性高
• 特点：面向对象
• 编译性解释语言：编译后会新建一个out文件

1.配置环境变量

JDK

JDK=Java Development Kit(Java开发工具)
提供了很多Java命令，像执行，编译等，并且JDK内置了JRE(Java运行环境)，提供了丰富的类库供我们调用去完成程序开发
Javac 编译chengcheng.lass
java 执行

配置环境变量

基础，跳过

编码格式改变成UTF-8

JRE配置

选择jdk环境里面的jre以便于以后可以直接看到源代码

2.编程准备

新建一个java project
新建一个package
新建一个class，第一个字母要大些

.HelloWorld示例

package test.lemmon;

public class HelloWorld {  //新建一个类
	
	/**主方法，程序执行的main，这里是程序自动执行的
	 * @param args
	 */
	 
	// 公开的任何人都可以调用，静态的，返回数据为空，main函数名称
	public static void main(String[] args){
		System.out.println("HelloWorld");		
	}
}

java文件设置

相比于py中一个文件可以存放多个类，java中也可以，但是：

• java文件中可以有多个类
• java文件中如果有一个public类，则这个public类必须和文件同名，且有且只有一个public类。也就是可以有其他私有类
• java中的类必须有一个main函数，类似于C中的main函数作为程序运行的起点。
• 推荐是一个文件一个类，类名和文件名一致
• 类名使用驼峰命名

编译和运行

• 1.javac工具把java程序编译成class程序
• 2.java虚拟机把class程序执行

src目录：存放源代码

IDEA的快捷键

保存：Ctrl + S
删除：Ctrl + D
撤回：Ctrl + Z
撤销：Ctrl + Y(恢复上一步操作，与CTRL+Z作用相反)
提示：alt + /   
注释：ctrl+/ ctrl+shift+/   command+ctrl+/
取消注释：ctrl+/  ctrl+shift+ \
查找：ctrl+f   
搜索：ctrl+h
代码行位置交换：alt+↓  alt+↑
下一行插入空行：Shift+Enter
代码格式化：ctrl+shift+f	
批量编辑：shift+alt+a
显示打开面板：alt+shift+w
搜文件名：Ctrl+shift+R
显示类结构：Ctrl+O
显示继承结构：Ctrl+T
代码格式化：Ctrl+Shift+F

3.分隔符

注释

单行注释

//
ctrl+/：增加注释
ctrl+/：取消注释

多行注释

	/*
	 *
	 */
ctrl+shift+/：增加注释
ctrl+shift+\：取消注释
	 

二.开始编程

1.Java基本类型

[外链图片转存失败(img-HLLgno2B-1566289224474)(DA8F2C45F37B453AADA2CDF6A947DF69)]

编译性的语言

2.编码规范

在命名文件的时候一般选择小驼峰命名方式，在命名类的时候一般选择大驼峰命名方式

3.引用数据类型

引用数据类型存储的是一个变量的地址，类似于指针
涉及的数据类型是：

• 类
• 接口
• 枚举

数组

• 一维数组

     //创建一维数组
        int[] arr1  = new int[4];
        int[] arr2 = {1,2,3,4};
    //这种可读性高
        arr1[i]= i;
    

有new的意思是开辟内存，长度是4个。一个数组的类型在初始的时候必须被定义，但是数组的长度可以不确定

• 当不确定数组长度的时候

// 数据类型 数组名称[] =null;(声明)
 String[] name2 = null;

• 然后实例化数组

//赋予长度
name2 = new String[3];

//赋值
name2[1] = "Wendy";

• 二维数组

创建二维数组

	//创建二维数组
		int [][] ary1 = new int [4][4];
		int [][] ary2 = {{1,2},{2},{3,6},{4,7}};	

4.运算符分类

基本分类

算术运算符
[外链图片转存失败(img-SIExohJG-1566289224476)(9886F28033F149D581F6E6CEAF1D1973)]

比较运算符
[外链图片转存失败(img-QQr0hrZm-1566289224477)(678C1F72F77048CB88C8FA15F8CABA2C)]

赋值运算符
[外链图片转存失败(img-DjMf7r5N-1566289224477)(BC1FEDACB634410DA4DC0880D4B515AE)]

逻辑运算符
[外链图片转存失败(img-Cxck8O3S-1566289224478)(8FA65C0E9D3040979304A45D8AF5F7BE)]

条件预算符

• A?B:C
• 如果A成立则执行B，否则执行C

运算顺序

1. ++
2. 括号
3. /,%(从左到右)
4. +,-(从左到右)

三.循环

1.for循环

• 普通的for循环

public class forfor {
	public static void main(String[] args){
		for (int i=0;i<5;i++){
			//换行输出
			System.out.println(i);
		}			
		for (int j=0;j<5;j++){
			//不换行输出
			System.out.print(j);
		}
		
		//普通for循环
		int[] arr={10,20,30};
		for (int i=0;i<arr.length;i++){
			System.out.println(arr[i]);
		}
	}
}

• 增强for循环（jdk1.5）

public static void main(String[] args){
        String[][] name = {
                {"Ben","Tom","Jack","seven1"},
                {"Ben","Tom","Jack","seven2"},
                {"Ben","Tom","Jack","seven3"}
        };

        for (String[] i:name){
            for (String j:i){
                System.out.println(j);
            }
            System.out.println("--------------");
        }
        /**
        *for(数组类型[] i:数组名称){
            
        }
        *把每次遍历的数组存放到i中
        *蕾西与python中的for i in Arry:
        */
    }

2.while循环

• do…while

		do{
			b=b+a;
		}
		while(a>0);

• while

		while(a>0){
			b=b+a;
			
		}

3.continue和break

• 跳出本次循环(忽略本次循环)continue
• 跳出整个循环(结束整个循环)break

4.if语句

• if…else if

int sixAge = 20;
		int shadowAge = 20;
		if (sixAge > shadowAge) {
			System.out.println("1:six是shadow的大哥");
		}else if (sixAge < shadowAge) {
			System.out.println("2:shadow是six的大哥");
		}else if (sixAge == shadowAge) {
			System.out.println("3:six的年龄和shadow的一样大");
		}

5.switch语句

switch(){
    case a:
    break;
    case b:
    break;
    
    default:
    break;
}

• 举个例子

int day = 8;
		switch (day) {
		case 1:
			System.out.println("这是星期一");
			break;
		case 2:
			System.out.println("这是星期二");
			break;
		case 3:
			System.out.println("这是星期三");
			break;
		case 4:
			System.out.println("这是星期四");
			break;
		case 5:
			System.out.println("这是星期五");
			break;
		case 6:
			System.out.println("这是星期六");
			break;
		case 7:
			System.out.println("这是星期天");
			break;
		default:
			System.out.println("非法的值");
			break;
		}

这里如果没有break，就会继续运行case

int day = 5;
		switch (day) {
		case 1:
		case 2:
		case 3:
		case 4:
		case 5:
			System.out.println("这是工作日");
			break;
		case 6:
		case 7:
			System.out.println("这是周末，大家可以去浪了");
			break;
		default:
			System.out.println("非法的值");
			break;
		}

default用于执行其他非case里面的场景

6.三段式

int sixAge = 22;
int shadowAge = 20;
String result = sixAge > shadowAge ? "six是shadow的大哥" : "six不是shadow的大哥";

类似于：if_else场景

if (sixAge > shadowAge) { // 如果条件满足才会进入这个分支，否则不会进入
			System.out.println("six是shadow的大哥");
		} else {
			System.out.println("six不是shadow的大哥");
		}

四.变量

局部变量&全局变量

局部变量：

• 1：必要要初始化
• 2：没有修饰符

String name = "six";

全局变量：

• 1：可以不用初始化，不初始化就为对应数据类型的默认值（缺省值null）
• 2: 有修饰符
• 3：但是注意当未空指针的时候访问它的属性或者方法回报错NullPointerException

private static int aInt = 10;

五.函数定义

在java中，定义函数需要三个部分：修饰符，类方法，返回值

修饰符

• public
• private
• protected

类方法

• static

返回值类型

这里就是java的基本数据类型

举个例子

修改符  static 返回值类型  方法名(形参类型  形参名,形参类型  形参名..)
{
//函数在这里
}

六.运算

和python不同的是，在java中字符串类型的比较使用的是equls，int类型的数据使用==比较。

Part 2

一.函数

1.函数的定义

    public static int add(int a,int b){
        return a+b;
    }

• 修饰符：public，protected，private，默认修饰符，从左往右权限逐渐降低。

访问权限	类	包	子类	其他包
public	v	v	v	v
protected	v	v	v	x
default	v	v	x	x
private	v	x	x	x

2.函数参数的不定项

多余输入参数不定的场景，这里需要一个多参数的输入值。

• 给定一个容器([] args)用于存储所有的参数，然后使用for循环把参数取出来。

public static int plus(int[] args){
        int sum = 0;
        for (int i=0;i<args.length;i++){
            sum += args[i];
        }
        return sum;
    }

• 另一种表示
• 这是JDK1.5的新特性可变参数

/**使用方法:
* public static 返回值类型 方法名称 {数组类型...参数名称}
*/

public static int plus(int...args){
        int sum = 0;
        for (int i=0;i<args.length;i++){
            sum += args[i];
        }
        return sum;
    }

3.函数的static

static静态函数，也就是类函数，当这个类没有被加载出来也可以调用的全局函数，参考例子1。

• 例子1

public class Test {
    public static void main(String[] args) {
		int result = plus(1, 2);
		int result2 = Test.plus(1, 2);
		System.out.println(result);
		System.out.println(result2);
    }

    public static int plus(int a, int b) {
        return a + b;
    }
}

• 但是，当没有加上static的时候，这个方法就是对象方法，需要实例这个类才可以使用

/**创建对象语法：
* 类名  对象名  = new 类名();
*/

public class Test {
    public static void main(String[] args) {
        Test tester = new Test();//创建一个对象
        System.out.println(tester.plus(11, 2));
    }
    
    public int plus(int a, int b) {
        return a + b;
    }
}

二.类与对象

类和对象是java的基础，

1.创建一个类

java本身就是以类为基础创建的

public class newMember {

    // 手机号
    public String phone;
    // 密码
    public String password;
    // 注册名
    public String regName;
    // 余额
    public double amount;

    // 1：注册
    public void register(String mobilePhone, String pwd) {
        if (mobilePhone.length() == 11 && pwd.length() == 6) {
            System.out.println("注册成功");
        } else {
            System.out.println("信息有误");
        }
    }

    // 2：登录
    public void login(String mobilePhone, String pwd) {
        if (mobilePhone.length() == 11 && pwd.length() == 6) {
            System.out.println("登录成功");
        } else {
            System.out.println("账号或者密码错误");
        }
    }
}

2.对象的使用

这里假设已经拥有一个已知的Member类，实例化一个对象叫shadow

// 类名称 对象名称 = new 类名称();
Member shadow = new Member();

• 或者是：

// 类名称 对象名称 = null; 
Member shadow = null;
// 对象名称 = new 类名称(); //实例化对象
shadow = new Member();

• 调用对象

public class newTester {
    public static void main(String[] args) {
        newMember shadow = new newMember();
        shadow.phone="13754000125";
        shadow.password ="123456";
        shadow.login(shadow.phone,shadow.password);
    }
}

3.构造函数

构造函数是存在于类中一个和类名相同的函数，在创建对象并初始化的时候会自动调用这个函数。

• python

    def __init__(self,uid):
        self.uid = uid
        self.date = GetTime()

• java

 public newMember(){
        System.out.println("这是个无参数的构造函数");
    }

• 然后需要输入参数时,需要使用this方法对输入的参数实例化

    public newMember(String phone) {
        this.phone = phone;
    }

三.内存地址（疑惑）

1.栈内存

理论比较复杂，通俗说的话栈内存是已经确定好大小的

• 同一个字符串，不同命名但是位置是相同的

String str1 = "hello";//字面值--》字符串池
System.out.println(System.identityHashCode(str1));//1531448569

String str0 = "hi";//字面值--》字符串池
System.out.println(System.identityHashCode(str0));//1867083167

String str2 = "hello";
System.out.println(System.identityHashCode(str2));//1531448569

2.堆内存

堆内存是针对对象来分配的,每次new的时候都会创建一个新的内存空间

String str3 = new String("hello");//通过new创建的--》堆内存
System.out.println(System.identityHashCode(str3));//284720968

String str4 = new String("hello");
System.out.println(System.identityHashCode(str4));//189568618

四.包装类

把基本数据类型封装成一个类，可以调用数据类型的方法进行数据处理。

Integer

• Integer.MAX_VALUE
• Integer.MIN_VALUE
  获取最大长度；获取最小长度
• Integer.parseInt(str)
  将字符串转为整型

int i = Integer.parseInt(str);
		System.out.println(i);

获取类型

public static String getType(Object test) {
		return test.getClass().getName();
	}

五.面向对象三大特征

1.封装

• public和protect和private
  在之前创建了一个Member类，拥有姓名手机这些属性

public class Member {
    public String phone;
    public String password;
    public String regName;
    public double amount;

}

但是这样的话属性是可以直接使用的

 public static void main(String[] args){
        Member june = new Member();
        june.phone = "1388888";
        System.out.println(june.phone);
    }

所以需要对属性的权限进行设置，换成private，在通过对外的函数来修改属性，这里增加setPhone和getPhone方法

public class Member {

    private String phone;
    private String password;
    private String regName;
    private double amount;

    public void setPhone(String phone){
	 	if (phone.length()==11) {
	 		this.phone = phone;
	 	}
	 	else
	 	    System.out.println("设置失败");
    }

    public String getPhone(){
        return phone;
    }
}

这样设置之后Tester就不可以直接对phone属性操作

public static void main(String[] args){
        Member june = new Member();
        june.setPhone("13838000238");
        System.out.println(june.getPhone());

    }

封装总结

• 将对象内部的属性封装起来，只提供操作对象属性的公共方法
• 通过公开方法访问数据,可以从方法里加入逻辑控制,避免不合理的访问可进行数据检查,保证数据完整性,防止不希望的交互和非法的访问便于后期修改,提高代码的可维护性封装的实现
• 主要表现：
• 1:属性私有化:隐藏对象的属性和实现细节,不允许外部直接访问
• 2:使用公开的方法操作和访问属性

2.继承

使用extends继承，用于继承父类的方法。

public class Borrower extends Member {}

重写

子类可以重新定义父类的方法，重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

3.多态

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。

多态的好处：

• 可以使程序有良好的扩展，并可以对所有类的对象进行通用处理

多态的实现方式：

• 方式一：重写：
• 方式二：接口
• 方式三：抽象类和抽象方法

重载

可以在同一个类中存在多个函数，函数名称相同但参数列表不同。这就是函数的重载（overlording）。这是类的多态性表现之一。

• 特征：
• 函数名和返回值类型完全一致。
• 参数的数量不同、或数量相同而类型和次序不同，以方便JVM区分到底调用哪个函数。

六.String类型

1.方法

• startsWith & endWith :判断是否以指定字符串开头或结尾

String str = "Hello World";
System.out.println(str.startsWith("H"));
System.out.println(str.endsWith("B"));

• substring：字符串截取
• 2:end 以及 2：5

String str2 = str.substring(2);
System.out.println(str2);
String str3 = str.substring(2, 5);
System.out.println(str3);

• split：字符串拆分

 String str4 = "He:llo:Wor:ld";
        String[] arry = str4.split(":");
        for (String i: arry) {
            System.out.println(i);
        }
        System.out.println(str4);

• indexOf：lastIndexOf： contains：字符串查找

 String str5 = "Hello World";
        //index:返回找到字符的首个位置，没有找到返回-1
        System.out.println(str5.indexOf("l"));
        //用于判断字符串中是否包含这个字符
        System.out.println(str5.contains("World"));
        //lastIndexOf() 方法可返回一个指定的字符串值最后出现的位置
        System.out.println(str5.lastIndexOf("l"));

• 字符串比较 equals : equalsIgnoreCase

    String str6 = "Hello World";
        String str7 = "hello world";
        //equals 用于判断两个字符串是否相同，区分大小写
        System.out.println(str6.equals(str7));
        //equalsIgnoreCase 用于判断两个字符串是否相同，不区分大小写
        System.out.println(str6.equalsIgnoreCase(str7));

• 字符串拼接 concat

      String str8 = "Hello";
        System.out.println(str8.concat("World"));

• 判空 isEmpty

        String str9 = "";
        System.out.println(str9.isEmpty());

• 替换 replace replaceFirst replaceAll

String str13 = "Hello World";
        //replace：替换这个字符串中的所有l成k
        System.out.println(str13.replace("l","k"));
        //replaceFirst：替换此字符串匹配给定的正则表达式的第一个子字符串，只换一个
        System.out.println(str13.replaceFirst("l","k"));
        //replaceAll：替换此字符串所有匹配给定的正则表达式的子字符串。
        System.out.println(str13.replaceAll("l","k"));

• valueOf：字符串描述

//返回给定参数的原生 Number 对象值;参数可以是原生数据类型, String等
        Integer a =Integer.valueOf(9);
        Double b = Double.valueOf(5);
        Float c = Float.valueOf("80");

        System.out.println(a);
        System.out.println(b);
        System.out.println(c);

Part 3

一.容器类

1.可变数组ArrayList

java已经封装好的类，但是这样的话并且通过<>括号设定这个数组的类型，也称为泛型

• 创建Array对象

import java.util.ArrayList;
ArrayList <String> arylist = new ArrayList();

• 添加数据 list.add(…);
• 但是添加其他类型的数据会报错

        arylist.add("Hello");
        arylist.add("Six");
        arylist.add("Five");
        arylist.add("Four");
        arylist.add("Three");

• 取出数据 list.get(index);

        String name = arylist.get(0);
		System.out.println(name);

• 移除数据：remove(…)

arylist.remove(1);
System.out.println(arylist.get(1));

• 获取list集合的大小：size()

int size = arylist.size();
System.out.println(size);

• isEmpty(…),判空函数

boolean flag = arylist.isEmpty();
System.out.println(flag);

• contains(…),判断是否包含某数据

System.out.println(arylist.contains("Happy"));

• set(…)，修改某个位置上的数据

        arylist.set(1, "Tom");
        System.out.println(arylist.get(1));

• 增强for循环

ArrayList<String> names = new ArrayList();
		names.add("Shadow");
		names.add("Six");
		names.add("Edsion");
		names.add("Edsion");

for (String name : names) {
			System.out.println(name);
		}

• 迭代器
• 当有下一个元素的时候就自动获取下一个元素

for (Iterator iterator = names.iterator(); iterator.hasNext();) {
			String name = (String) iterator.next();//获得下一个元素
			System.out.println(name);
		}

另一种写法

while(iterator.hasNext()){
			String string = (String) iterator.next();
			System.out.println(string);
		}

2.HashSet

java已经封装好的类，特点：

• 数据排列是无序的
• 数据不可以重复

        HashSet<String> haset = new HashSet<String>();

• 添加数据

        haset.add("Shadow");
        haset.add("six");
        haset.add("six");
        haset.add("Edsion");
        System.out.println(haset);
        //[Edsion, six, Shadow]

• size() 获取集合的大小
• 移除数据：remove(…)
• contains(…),判断是否包含某数据
• clear(), 将集合里的所有数据清空

        haset.clear();
     	System.out.println(haset.size());

• toArray(),将集合转化成为对应数据类型的数组

//获取haset里面的元素形成一个数组
Object[] objects = haset.toArray();
		for (Object object : objects) {
		//把数组里面的数据取出，转换成对应的字符串
			String str = (String) object;
			System.out.println(str);
		}

3.HashMap

以键值对的形式来保存数据，键不可以重复，类似于字典

HashMap<String, String> haMap = new HashMap<>();

• 存放数 据put(…,…)

hamap.put("regName", "Shadow");
hamap.put("Hello", "World");
hamap.put("age", "20");
hamap.put("gender", "男");
System.out.println(hamap);
//{Hello=World, regName=Shadow}

• 取数据 get(…)

String name = hamap.get("regName");
System.out.println(name);
//Shadow

• 移除：remove(…)

hamap.remove("age");
System.out.println(hamap.get("age"));
//null

• 获取所有的键：keySet(…)
• 使用此方法可以获所有键值对的集合，set类型
• hashset是set的一个子类，所以会拥有set集合的所有方法

Set<String> set = hamap.keySet();
		for (String key : set) {
			System.out.println(key);
		}

• 获取或有的值：values(…)
• 和key不同的是value可以的话重复的，但是key是唯一的

Collection<String> values = hamap.values();
		for (String value : values) {
			System.out.println(value);
		}

• size()
• containsKey(…)
• containsValue(…)
• 遍历

//获得map的所有的key 的集合（固定api，获取所有的key的集合）
		Set<String> keySet = map.keySet();
		//遍历这个key的集合，把所有的值都遍历出来
		for (String key : keySet) {
			System.out.println(key + "-->" + map.get(key));
		}

//借助Entry模块
        for (Map.Entry entry : hamap.entrySet()) {
            System.out.println(entry.getKey()+":"+entry.getValue());

        }