Java基础学习

JavaSE学习

一、Java基础知识

1. DOS常用命令

命令	注释
help	查看所有命令
cd ..	返回上一级目录
cd 文件名	目录切换到该文件名（子目录）下
cd \	回根目录
dir	当前根目录下的文件目录
dir /s	所有目录
md或mkdir 文件名	创建目录
rd或者rmdir 文件名	移除目录
copy 要复制的文件名复制到的路径或文件夹	将一个或多个文件复制到另一个位置
del 文件名	删除文件
ren 文件名新文件名	重命名
tree	显示文件目录树，含最底层目录
Ctrl+C	中断操作
cls	清空屏幕
exit	退出
ver	查看系统版本
ipconfig	查看电脑和网络地址
ipconfig /all	显示所有网络适配器的完整TCP/IP配置信息

2. JVM、JRE、JDK之间的关系

JDK(Java Development Kit) ，Java 语言的软件开发工具包

JRE(Java Runtime Environment)，Java运行环境

JVM(Java Virtual Machine)，Java虚拟机

JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。

JDK是整个Java的核心，包括了Java运行环境JRE、Java工具和Java基础类库。JRE是运行JAVA程序所必须的环境的集合，包含JVM标准实现及Java核心类库。JVM是整个java实现跨平台的最核心的部分，能够运行以Java语言写的程序。

3. Java开发环境搭建

在Oracle官方网站下载JDK：http://www.oracle.com/index.html

下载java JDK，安装路径更改为：C：\Java\jdk1.8.0_65
安装JRE 安装路径为：C：\Java\jre8（若此路径没有，可以手动添加）
新建环境变量，变量名：JAVA_HOME 变量值：C：\Java\jdk1.8.0_65 （JDK安装路径）
配置环境变量Path 最前端添加：.;%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin
运行javac ,java -version

4. Java开发流程

需求分析
设计原型
需求文档
交互文档
设计美化
前端
研发
测试/项目验收

5. Java基础

5.1 Java主类结构

5.1.1 包声明

package 包名

package com.*;

5.1.2 成员变量和局部变量

成员变量（全局变量）生命在类体中，有效范围：整个类都有效。又分为静态变量和实例变量，静态变量的有效范围可以跨类，调用方式：类名.静态变量。

局部变量生命在方法体中，有效范围：当前定义的方法类中有效。生命周期取决于方法，方法调用结束会释放局部变量占用的内存空间。

public class First {
	static String s1="你好"; //成员变量（全局变量）
	public static void main(String[] args) {
		String s2="Java"; //局部变量
		System.out.println(s1);
		System.out.println(s2);
	}

}

5.1.3 主方法

main()方法

public static void main(String[] args){

}

5.1.4 API库

import导入相关的类

java主要的类：

java.applet 提供创建 applet 所必需的类和 applet 用来与其 applet 上下文通信的类。
java.awt 包含用于创建用户界面和绘制图形图像的所有类。
java.beans 包含与开发 beans 有关的类，即基于 JavaBeansTM 架构的组件。
java.io 通过数据流、序列化和文件系统提供系统输入和输出。
java.lang 提供利用 Java 编程语言进行程序设计的基础类。
java.math 提供用于执行任意精度整数算法 (BigInteger) 和任意精度小数算法 (BigDecimal) 的类。
java.net 为实现网络应用程序提供类。
java.nio 定义作为数据容器的缓冲区，并提供其他 NIO 包的概述。
java.security 为安全框架提供类和接口。
java.sql 提供使用 JavaTM 编程语言访问并处理存储在数据源（通常是一个关系数据库）中的数据的 API。
java.text 提供以与自然语言无关的方式来处理文本、日期、数字和消息的类和接口。
java.util 包含 collection 框架、遗留的 collection 类、事件模型、日期和时间设施、国际化和各种实用工具类（字符串标记生成器、随机数生成器和位数组）。

5.2 基本数据类型

        byte mybyte = 124;
		short myshort = 32564;
		int myint = 45784612;
		long mylong = 46789451;
		long result = mybyte + myshort + myint + mylong;
		char x = 'a';
		boolean flag=true;

5.2.1 数值型

整数类型

byte 内存空间：8位 -128~127
short 内存空间：16位
int 内存空间：32位
long 内存空间：64位

浮点类型

float 内存空间：32位
double 内存空间：64位

5.2.2 字符型

char 内存空间：16位

5.2.3 布尔型

boolean True/False

5.3 运算符

5.3.1 运算赋值

“=”赋值

5.3.2 自增和自减赋值

a++ 先赋值后运算

i=a++;   //先赋值，后运算
//i=a;a=a+1;

++a 先运算后赋值

i=++a;  //先运算，后赋值
//a=a+1;i=a;

5.3.3 逻辑运算符

&&和&的区别？

&&是短路运算符，当一个表达式为false时，不会去判断第二个表达式

&是非短路运算符会判断两个表达式

5.3.4 位运算符

原码：正数符号为为0，负数符号位为1；例：10001000 - 8的原码
反码：符号位不变，其余取反；例：11110111 -8的反码
补码：负数补码=反码+1；例：11111000 -8的补码表示二进制
左移：右边移空的部分补0，a<<n等于 a*2^n；
右移：左边移空的部分补1, a>>n等于 a/2^n；

5.3.5 三元运算符

a<b?x:y

例：20<45?true:false

5.3.6 运算优先级

由高到低：

增量和减量运算
算术运算
比较运算
逻辑运算
赋值运算

5.4 数据类型转换

5.4.1 隐式转换

低精度赋值给高精度，自动转换

精度从低到高排序：byte<short<int<long<float<double

int x=50;
float y=x;

5.4.2 显示转换

高精度变量赋值给低精度变量，强制转换

int a=(int)45.23;        //输出45
long y=(long)456.6F;     //输出456
int b=(int)'b';          //输出100

6. 流程控制

6.1 条件语句

6.1.1 if

if(布尔表达式){
    语句序列;
}

6.1.2 switch...case

case常量值必须互不相同

switch(整型、字符型或字符串类型){
    case 1:
        语句块1;
        break;
    case 2:
        语句块1;
        break;
}

6.2 循环语句

6.2.1 while

while(条件表达式){
    执行语句;
}

6.2.2 do...while

至少执行一次

do{
    执行语句;
}while(条件表达式)

6.2.3 for

for(i=0;i<n;i++){
    循环N次;
}

6.2.4 foreach

/*
for(元素变量 x:遍历对象 ob){
    引用了x的java语句;
}
*/
for(Student s:list){
    System.out.println(s);
}

6.3 循环控制

6.3.1 break

跳出循环结构，也可以跳出当前循环体，中断当前循环

6.3.2 continue

跳过本次循环，回到循环条件测试部分，重新开始循环。

7. 练习

7.1 for循环打印菱形

import java.util.Scanner;

/*
 * 打印（2*n-1）层的菱形
 *     *
 *    ***
 *   *****
 *    ***
 *     *
 * 横，列总数：5    2n-1
 */
public class demo1 {
	public static void main(String[] args) {
		int i, j,k,n;
		// 循环打印一个菱形的上半部分
		Scanner scanner=new Scanner(System.in);
		n=scanner.nextInt();
		//第n层
		for(j=1;j<=n;j++) {
			//第j层
			for(i=0;i<(n-j);i++) {
				System.out.print(" ");
			}
			for(k=0;k<(2*j-1);k++) {
				System.out.print("*");
			}
			System.out.println();
		}
		//打印下半部分
		for(j=1;j<=n-1;j++) {
			//第一层
			for(i=0;i<j;i++) {
				System.out.print(" ");
			}
			for(k=0;k<(2*(n-j)-1);k++) {
				System.out.print("*");
			}
			System.out.print("\n");
		}
		
	}
}

7.2 while循环语句计算，1+1/2！+1/3！+...+1/20！之和

import java.util.Scanner;

import org.junit.Test;

/*
 * while 输出阶层
 */
public class demo2 {
	public static void main(String[] args) {
		float i = 1;
		long k = 1;
		float s = 0.0f;
		int j, m;
		while(i<20){
			k *= i;
			i++;
			System.out.println(k);
			s +=  1.0 / k;
		}
		System.out.println(s);
	}
	
	@Test
	//从控制行输入一个数，输出该数的阶层
	public void test() {
		int i;
		long l=1;
		Scanner scanner=new Scanner(System.in);
		Integer integer=scanner.nextInt();
		for(i=1;i<=integer;i++) {
			l*=i;
		}
		System.out.println(l);
	}
}

8 字符串

8.1 String类

声明字符串必须经过初始化

用字符数组a创建String对象

 char a[]= {'a','b','c'};
 String s=new String(a);
 System.out.println(s); //输出abc

提取字符数组a中的一部分创建String对象

char x[]={'a','b','c','d','e','f'};
String y=new String(x,2,4);
System.out.println(y);   //输出cdef

8.2 连接字符串

使用“+”运算符

String a,b,c;
System.out.println(a+b+c);

8.3 获取字符串信息

8.3.1 长度

String str;
str.length();

8.3.2 查找

//indexOf返回字符串s在指定字符或字符串中首次出现的位置
String str;
String s;
str.indexOf(s);

//lastIndexOf返回的指定字符或者字符串最后一次出现的位置
String str;
String s;
str.lastIndexOf(s);

8.3.3 获取指定索引位置的字符

//str.charAt(int index);
String str1="hello world!";
char c=str1.charAt(1);
System.out.println(c);    //输出e

8.4 字符串操作

8.4.1 获取子字符串的位置(str.substring(int index))

substring()

//str.sbustring(int beginIndex);
String str1="hello world!";
String s2=str1.substring(3);
System.out.println(s2);   //输出lo world！

8.4.2 去除空格

trim();

忽略前后空格

//str.trim();
String str1=" hello world! ";
String str3=str1.trim();
System.out.println(str3);  //输出hello word！

8.4.3 字符串替换

replace

//str.replace(char oldChar,char newChar)
String str="adasawwqwrqwqqwrqrqad";
String str4=str.replace("a", "x");
System.out.println(str4);   //输出xdxsxwwqwrqwqqwrqrqxd

8.4.4 判断字符串的开始与结尾

String str="adasawwqwrqwqqwrqrqad";
//str.startswith(String s)
System.out.println(str.startsWith("ada"));    //输出true
//str.endswith(String s)
System.out.println(str.endsWith("ad"));       //输出true

8.4.5 判断字符串是否相等

equals()方法

具有相同的字符和长度则返回true，区分大小写

//str.equals(String otherstr)
String m="abc";
String n="ABC";
System.out.println(m.equals(n)); //false

equalsIgnoreCase()方法

忽略大小写比较

//str.equalsIgnoreCase(String otherstr)
String m="abc";
String n="ABC";
System.out.println(m.equalsIgnoreCase(n));   //tue

8.4.6 按字典顺序比较两个字符串

String对象位于参数字符串之前则返回一个负整数

String对象位于参数字符串之后则返回一个正整数

两个字符串相等返回0

compareTo方法只有在equals()方法返回true时才返回0

//str.compareTo(String otherstr)
String e="a";
String f="b";
String g="c";
System.out.println(f.compareTo(f));    //1
System.out.println(f.compareTo(g));    //0
System.out.println(f.compareTo(g));    //-1

8.4.7 字母大小写替换

toLowerCase()方法

将String转换为小写

//str.toLowerCase()
String str5="ALSAFLIHAAHG";
System.out.println(str5.toLowerCase());   //alsaflihaahg

toUpperCase()方法

将String转换为大写

//str.toUpperCase()
String str6="asfagadgaaa";
System.out.println(str6.toUpperCase());   //ASFAGADGAAA

8.4.8 字符串分割

split()方法

sign为分割字符串的分隔符，也可以使用正则表达式

//str.split(String sign)
        	String str7="127.0.0.1";
        	String[] arr=str7.split("\\.");
        	for(String str8:arr) {
        		System.out.print(str8+"\\");    //127\0\0\1\
        	}
//str.split(String sign,int limit)
            	String str7="127.0.0.1";
        	String[] arr=str7.split("\\.",2);
        	for(String str8:arr) {
        		System.out.print(str8+"\\");   //127\0.0.1\
        	}

8.5 格式化字符串

format()方法，创建格式化字符串

8.5.1 日期和时间格式化

常用的日期格式化转换符

转换符	说明	示例
%te	一个月中的某一天（1~31）	2
%tb	指定语言环境的月份简称	Feb（英文）、二月（中文）
%tB	指定语言环境的月份全称	February（英文）、二月（中文）
%tA	指定语言环境的星期几全称	Monday（英文）、星期一（中文）
%ta	指定语言环境的星期几简称	Mon（英文）、星期一（中文）
%tc	包括全部日期和时间信息	星期二三月 25 13:27:22 CST 2018
%tY	4位年份	2018
%tj	一年中的第几天（001~366）	085
%tm	月份	03
%td	一个月中的第几天（01~31）	02
%ty	2位年份	18

常用时间格式化转换符

转换符	说明	示例
%tH	2位数字的24小时制的小时（00~23）	14
%tI	2位数字的12小时制的小时（01~12）	05
%tk	2位数字的24小时制的小时（0~23）	5
%tl	2位数字的12小时制的小时（1~12）	10
%tM	2位数字的分钟（00~59）	05
%tS	2位数字的秒数（00~60）	12
%tL	3位数字的毫秒数（000~999）	920
%tN	9位数字的微秒数（000000000~999999999）	062000000
%tp	指定语言环境下上午或下午标记	下午（中文）、pm（英文）
%tz	相对于GMT RFC 82 格式的数字时区偏移量	+0800
%tZ	时区缩写形式的字符串	CST
%ts	1970-01-01 00:00:00 至现在经过的秒数	1206426646
%tQ	1970-01-01 00:00:00 至现在经过的毫秒数	1206426645453

常见的日期和时间组合的格式化

转换符	说明	示例
%tF	“年-月-日”格式（4位年份）	2018-9-18
%tD	“月/日/年”格式（2位年份）	09/18/18
%tc	全部日期和时间信息	星期二三月 25 15:20:00 CST 2018
%tr	“时:分:秒 PM（AM）”格式（12时制）	03:22:06 下午
%tT	“时:分:秒”格式（24时制）	15:23:50
%tR	“时:分:秒”格式（24时制）	15:25

Date date=new Date();
        	String str8=String.format("%te", date);
        	System.out.println(str8);    //输出24   24号
        	String str9=String.format("%tH", date);
        	System.out.println(str9);    //输出14 14点

8.5 正则表达式

str.matches(String s)

s：正则表达式

通常被用于判断语句中，检查某一字符串是否满足格式

“.”代表任何一个字符

[]括起来的字符表示一个元字符，该元字符可以代表方括号中的任何一个字符。

[abc]4：a4,b4,c4都是和正则表达式匹配的字符串

[^456]：代表4、5、6以外的任何字符

[a-r]：a-r中的任何字符

...

允许使用限定修饰符来限定元字符出现的次数。

？：0或者1次

*：0或者多次

+：1或者多次

{n}：正好出现n次

{n,}：至少出现n次

{n,m}：出现n~m次

8.6 字符串生成器

Stringbuilder

追加字符串：append()
插入字符串：insert()
删除字符串：delete()

9.数组

9.1 一维数组

先声明，再用new进行内存分配

int a[];
int[] a;
a=new a[10];   //new分配空间
int a[]=new int[10];

整数数组中各个元素初始值为0

int arr[]=new int[]{1,2,3,4,5};
int arr[]={1,2,3,4,5,6};

9.2 二维数组

int a[][]=new int[2][4];  //分配空间

//分别为每一行分配
int a[][]=new int[2][];
a[0]=new int[2];
a[1]=new int[3];
a[2]=new int[3];
int arr[][]={{1,2},{3,4,5},{6,7,8}};    //初始化二维数组
int arr[1][2]=20;   //为指定下标赋值

9.3 数组的基本操作

9.3.1 遍历数组

for()和foreach()

//遍历一维数组
public class Iterator {
    public static void main(String[] args) {
        int a[]=new int[]{1,2,4,62,1,64,58,9};
        //for()
        for(int i=0;i<a.length;i++){
            System.out.print(a[i]+" ");  //1 2 4 62 1 64 58 9
        }
        System.out.println();
        //foreach()
        for (int b:a) {
            System.out.print(b+" ");    //1 2 4 62 1 64 58 9
        }
    }
}

//遍历二维数组
public class Iterator1 {
    public static void main(String[] args) {
        int a[][]={{1,2,3},{4,5,6},{7,8,9},{1,1,1}};
        System.out.println(a.length);     //4行 
        //for()
        for(int i=0;i<a.length;i++){
            for(int j=0;j<a[i].length;j++){
                System.out.print(a[i][j]+" ");  //1 2 3 4 5 6 7 8 9 1 1 1 
            }
        }
        System.out.println();
        //foreach()
        for(int b[]:a){
            for(int c:b){
                System.out.print(c+" ");       //1 2 3 4 5 6 7 8 9 1 1 1
            }
        }
    }
}

Arrays.toString()：遍历一维数组

//Arrays.toString()
System.out.println(Arrays.toString(a)); //[1, 2, 4, 62, 1, 64, 58, 9]

9.3.2 替换和填充数组

fill()

import java.util.Arrays;

public class Array {
    public static void main(String[] args) {
        int a[]=new int[3];
        //fill(int a[],int value)  向a数组填充值value
        Arrays.fill(a,9);    //向a数组填充9
        for(int i:a){
            System.out.print(i+" ");  //999
        }
        System.out.println();
        //fill(int a[],int fromIndex,int toIndex,int value)
        //将a数组指定范围的元素填充 （fromIndex包括，toIndex不包括）
        Arrays.fill(a,0,1,2);
        for(int i:a){
            System.out.print(i+" ");  //299
        }
    }
}

9.3.3 排序

sort()方法对数组进行升序排序

//Arrays.sort(object)
import java.util.Arrays;

public class ArraySort {
    public static void main(String[] args) {
        int a[]={121,1223,765,1,98,43,132,76,234,7};
        Arrays.sort(a);
        System.out.println(Arrays.toString(a)); 
        //[1, 7, 43, 76, 98, 121, 132, 234, 765, 1223]

    }
}

9.3.4 复制

copyOf：复制数组，制定新的数组长度

//copyOf(arr,int newlength)
public class ArrayCopyOf {
    public static void main(String[] args) {
        int a[]={1,2,3,4,5,6,7,8,9,0};
        int[] ints = Arrays.copyOf(a, 5);
        System.out.println(Arrays.toString(ints));   //[1, 2, 3, 4, 5]
    }
}

copyOfRange：有范围的复制数组

//copyOfRange(arr,int fromIndex,int toIndex)   fromIndex包括，toIndex不包括
int[] ints1 = Arrays.copyOfRange(a, 1, 4);
System.out.println(Arrays.toString(ints1));  //[2, 3, 4]

9.3.5 查询

二分法查找

/*
二分法查找
 */
public class Demo9 {
    public static void main(String[] args) {
        int[] a = new int[10];
        for(int i=0;i<10;i++){
            a[i]= (int) ((Math.random())*100);
        }
        System.out.println(Arrays.toString(a));
        int value = 10;
        int i = binarySearch(a, value);//找不到返回-1
        System.out.println((i == -1) ? value + "不存在" : value + "在数组中的下标是" + i);

    }

    //折半查找的核心算法
    public static int binarySearch(int[] a, int value) {
        int begin = 0;
        int end = a.length - 1;
        //循环
        while (begin <= end) {
            int mid = (begin + end) / 2;
            if (a[mid] == value) {
                return mid;
            } else if (a[mid] > value) {
                end = mid - 1;
            } else if (a[mid] < value) {
                begin = mid + 1;
            }
        }
        return -1;
    }
}

binarySearch()

如果查得到，返回搜索值的索引，否则返回-1或者该值要插入的位置

查找前必须排序

import java.util.Arrays;

public class binarySearch {
    public static void main(String[] args) {
        int a[]={123,243,7658,12,46,98,10,657,131,77};
        Arrays.sort(a);
        //binarySearch(Object[] a,Object key)
        int i = Arrays.binarySearch(a, 12);     //1
        System.out.println(i);
        //binarySearch(Object[] a,int fromIndex,int toIndex,Object key)  指定范围查找
        int i1 = Arrays.binarySearch(a, 0, 3, 123);
        System.out.println(i1);    //-4   123要插入的位置
    }
}

9.4 数组的排序算法

9.4.1 冒泡排序

两两交换

/*
* 冒泡排序
* */
public class demo2 {
    int[] a=new int[]{2,3,2,12,75,6,32,12,658,32,8652,212};
    int i,j,k;
    public void getArray(){
        for(i=0;i<a.length;i++){
            for(j=0;j<a.length-1;j++){
                if(a[j]<a[j+1]){
                    k=a[j];
                    a[j]=a[j+1];
                    a[j+1]=k;
                }
            }
        }
        System.out.println(Arrays.toString(a));
    }

    public static void main(String[] args) {
        demo2 d=new demo2();
        d.getArray();
    }
}

9.4.2 直接选择排序

每一次循环找出最小值，交换

/*
* 选择排序
* */
public class Demo4 {
    int i,j,min,temp;
    public void sort(int[] a){
        for(i=0;i<a.length;i++){
            System.out.println(i);
            min=i;
            for(j=i;j<a.length;j++){
                if(a[j]<a[min]){
                    min=j;
                }

            }
            System.out.println(a[min]);
            temp=a[i];
            a[i]=a[min];
            a[min]=temp;
            System.out.println(Arrays.toString(a)+i);
        }
    }

    public static void main(String[] args) {
            int[] a=new int[]{23,543,11,435,776,44,432};
        Demo4 demo4=new Demo4();
        demo4.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

9.4.3 反转排序

数组第i个和第(a.length-1-i)个交换

import java.util.Arrays;

//数组反转
public class ArrayReverse {
    public static void main(String[] args) {
        int temp,k;
        int a[]={1,2,3,4,5,6,7,8,9};
       //i和a.length-1-i交换，偶数交换到a.length/2个停止，奇书交换到(a.length-1)/2
        k=a.length; //数组长度  9
        //System.out.println(k);
        if(k%2==0){
            for(int i=0;i<k/2;i++){
                temp=a[i];
                a[i]=a[k-1-i];
                a[k-1-i]=temp;
            }
        }
        else{
            for(int i=0;i<(k-1)/2;i++){
                temp=a[i];
                a[i]=a[k-1-i];
                a[k-1-i]=temp;
            }
        }
        System.out.println(Arrays.toString(a));  //[9, 8, 7, 6, 5, 4, 3, 2, 1]
    }
}

10. 类和对象

10.1 概述

现实世界中，随处可见的一种事物就是对象。通常会将对象划分为两个部分：静态部分和动态部分。

静态部分称为属性，而具有这些属性的人会执行的动作叫做动态部分。

面向对象来解决问题：

从问题中抽象出对象。
识别对象的属性。
识别这个对象的动作行为。
识别这个对象的属性和行为后，这个对象就被定义了。

10.2 类

类就是同一事物的统称。

类实质上就是封装属性和对象的载体。

反过来说，具有相同属性和行为的一类实体被成为类。、

10.3 封装

封装是面向对象的核心思想。用户不能轻易的直接操作数据结构，只能执行类允许公开的数据。

避免了外部操作对内部数据的影响，提高了程序的可维护性。

10.4 继承

继承是关联的一种。

继承思想可以缩短软件开发的时间，复用那些已经定义好的类可以提高系统性能，减少系统在使用过程中出现错误的几率。

10.5 多态

将父类对象应用于子类的特征。

多态性允许以统一的风格编写程序，以处理种类繁多的已存在的类及相关类。

根据父类统一风格的处理，可以实例化子类的对象

抽象类不能实例化对象

10.6 类

10.6.1 成员变量

对象的属性，用class关键字类定义类

10.6.2 成员方法

使用成员方法对应于类对象的行为

无返回值用void表示

10.6.3 权限修饰符

public、protected、default、private

作用域	当前类	同一包	其他包的子类	其他包的类
public	√	√	√	√
protected	√	√	√	×
default	√	√	×	×
private	√	×	×	×

10.6.4 局部变量

成员方法内定义的变量

成员变量在使用时必须进行赋值操作或初始化，否则会出现编译错误

10.6.5 局部变量的有效范围

从该变量的声明开始到该变量的结束为止

10.6.6 this关键字

this可以调用成员变量和成员方法。

this引用的就是本类的一个对象，在局部变量或参数覆盖了成员变量时，要添加this关键字明确引用的是类成员还是局部变量和成员方法。

private String name;
public void setName(String name){
    this.name=name
}

10.6.7 类的构造方法

有参构造和无参构造

构造方法没有返回值
构造方法的名称要和本类名称相同
构造方法没有返回值

编译器会自动创建一个无参构造

public class Student{
    public Student(){} //无参构造
    public Student(String name){}   //有参构造
}

this关键字可以调用类中的构造方法，但是只可以在无参构造的第一句使用this调用有参构造方法

public class Anything{
    public Anything(){
        this("this调用了有参构造");
        System.out.println("无参构造");
    }
    public Anything(String str){
        System.out.println(str);
    }

    public static void main(String[] args) {
     new Anything();  
    }
}

10.6.8 静态变量、常量和方法

static关键字修饰的变量方法叫做静态变量，静态方法

静态方法、变量被成为静态成员，静态成员属于类所有。

调用：类名.静态类成员

静态方法不可以使用this

不可以直接调用非静态方法

执行类时首先执行静态代码块，且只执行一次

10.6.9 类的主方法

主方法是静态的，所以要在主方法中调用其他方法，则该方法也必须是静态的。

主方法没有返回值。

主方法的形参为数组。

public static void main(String[] args) {
        
    }

10.7 对象

对象是由类抽象出来的

10.7.1 创建

new一个对象，调用构造方法创建对象

Student student=new Student();

10.7.2 访问对象和属性和行为

对象.类成员

student.getName();

10.7.3 引用

类名对象引用名称

Student stu;

10.7.4 比较

equals()：比较两个对象的内容是否相同

==：比较两个对象的地址是否相同

public class Equals {
    public static void main(String[] args) {
        String a=new String("abc");  //a 分配了内存空间
        String b=new String("abc");  //b分配了内存空间
        String c=a;                          //a赋值给c，指向同一个内存空间
        System.out.println(a.equals(b));   //true 
        System.out.println(a==b);          //false
        System.out.println(a==c);          //true
    }
}

10.7.5 销毁

当生命周期结束时，分配给对象的内存地址将会被回收，java拥有一整套完成的垃圾回收机制。只能回收new创建的对象。不能回收不是用过new获取的内存。

finalize()方法：在垃圾回收时会首先调用该方法，回收被对象占用的内存。

11. 包装类

11.1 Integer

11.2 Boolean

11.3 Byte

11.4 Character

11.5 Double

11.6 Number

12 数字处理类

12.1 数字格式化

DecimalFormat

实例化DecimalFormat对象时传递数字格式，也可以通过applyPattern()方法

//pattern:格式  value:数字
//new DecimalFormat(pattern).format(value);
 String format = new DecimalFormat("000.###").format(12.241);
 System.out.println(format);   //012.241
//applyPattern()
DecimalFormat myformat=new DecimalFormat();
myformat.applyPattern(pattern);
myformat.format(value);

12.2 数学运算

12.2.1 Math类

提供了众多数学函数方法，都被定义为static

调用：Math.数学方法

12.2.2 取整函数方法

Math.ceil(double a) 向上取整
Math.floor(double a) 向下取整
Math.rint(double a) 取最近的整数，有0.5的话取偶整数

Math.round(double a) 四舍五入

public class math {
    public static void main(String[] args) {
        System.out.println(Math.ceil(9.1));   //向上取整 10
        System.out.println(Math.floor(9.9));  //向下取整 9
        System.out.println(Math.rint(9.5));   //靠近的整数有9和10，取偶数  10
        System.out.println(Math.rint(9.9));   //靠近10 10
        System.out.println(Math.round(9.4));  //四舍五入 9
    }
}

12.2.3 随机数

0<Math.random()<1.0 随机产生0~1的数

int a= (int) (Math.random()*20);   //0~20的随机数

12.3.4 Random类

可以实例化一个Random对象创建一个随机数生成器

12.3.5 大数据运算

BigInteger

比Integer数据类型的范围要大得多

BigDecimal

在BigInteger的基础上加入了小数的概念

13. 循环嵌套

for(i=0;i<n;i++){
    for(j=0;j<n;j++){
        
    }
}

14. 方法的形参和实参

实参：有确切的值，赋值给形参

形参：方法中定义的参数

15. 方法的递归调用

自己调用自己

//递归实现斐波那契额
//递归实现斐波那契数列
//斐波那契数列：1，1，2，3，5，8
//第i个=第i-1个+第i-2个
public class demo11 {
    public static void main(String[] args) {
        demo11 demo=new demo11();
        int a= demo.demo(5);
        System.out.println(a);
    }
    public int demo(int i) {
        if(i==1||i==2){
            return 1;
        }
        else
            return demo(i-1)+demo(i-2);
    }
}

posted @ 2020-04-25 10:59 糊你一脸羊毛阅读(169) 评论(0) 收藏举报

刷新页面返回顶部