Java基础

本文隶属于分类

编程语言

推荐文章

广告推荐

技术交流学习或者有任何问题欢迎加群

编程技术交流群 : 154514123 爱上编程      Java技术交流群 : 6128790  Java

标签:next()   类文件   with   完整   binary   spl   特性   重写   face   

什么是Java?
    Java是一种编程语言,Java可以撰写跨平台应用软件,是由Sun 公司与1995年推出的程序设计语言和Java平台(JavaEE,JavaME,JavaSE)的总称。
Java的历史
    2010年Oracle公司收购了Java。
Java的体系
    JavaSE java平台标准版 桌面版
    JavaEE java平台企业版 大型网站
    JavaME java平台微型版 手机 移动终端
Java的开发环境
    Eclipse、Myeclipse、InteliJ Idea、Jbuilder等等。
Java程序的运行
    运行java需要在java虚拟机中,也叫做JVM,它是java运行环境的一部分,java运行环境又称为JRE。只要电脑中安装了JRE,就可以运行java程序。
 
1.源文件:Java的源代码是.java结尾的文件。
2.编译:然后通过编译器把源文件翻译成字节码文件,为.class文件
3.运行:最后使用解释器来运行字节码文件。
 
JDK是Java语言的开发包,可以将.java文件编译为可执行的Java程序。
可执行Java程序需要JVM才可以运行。 
JRE(运行环境)包含了JVM(虚拟机)。
JDK包含了JRE
 
什么是JRE?
 JRE(Java Runtime Environment,java运行环境),运行Java程序所需要的环境集合,包含了JVM标准实现及Java核心类库,仅能够完成java的运行,无法对java进行编译、调试等。
 
什么是JDK?
JDK(Java Development Kit)是Java语言的软件开发工具包(SDK),是面向Java开发者发布的Java套件。
JDK包含的基本组件包括:编译器、Jar打包工具、Javadoc文档生成器、Debug调试器、头文件生成器、反汇编器、监控工具等。
JDK中包含完整的JRE
 
InteiliJ IDEA 
安装Idea、可添加插件->Preferences->Plugins->Install
常用插件:
activate-power-mode 打字轰炸效果
CodeGlance 类似minimap 右边小地图
IDEA快捷键:
option+command+L 代码格式化
注视 command+/
导入包 option+回车
移动代码行 command+shift+上下
进入类 command+左键点击
 
 
调试:
F7、F8 下一步
 
检查是否安装java
打开终端 输入 java -version 如果安装了会提示当前安装的版本 如果没安装需要安装https://java.com/zh_CN/
 
然后安装 java jdk
 
项目结构
src项目源文件 com.xxx.baidawei 每一个.一个文件夹
Libraries 引用的包文件
 
注视:  //单行 /**/ 多行 文档注视/** */
关键字:Java中的关键字均为小写,如 class void static public等等。
 
变量 可变的量 为内存中的数据起别名
常量 不可变的量 
数据类型:
    基本数据类型:整数(byte 、short、int、long)、小数(float、double)、字符(char)、布尔(boolean)
        Java中默认的整数类型是int类型,如果定义long需要后面加一个L。
        Java中默认的浮点类型是double类型,如果定义为float类型后面需要加一个F。
    引用数据类型:字符串(String)、数组、类、接口
定义变量 类型 变量1,变量2,变量n
byte score; int sumScore;long fileSize; float x,y; short age; double result; char sex;boolean isa; String name;大写的string
变量的初始化
age=23;score = 70+5;i=10/5;result=3.5;sex=‘男’;isa = true;name=‘张飞’;
变量的命名规则:首字母是 英文字母、$或下划线,由字母数字、下划线组成,尽量有意义如sex,在java中变量首字母小写 与类名、接口名区分,驼峰命名法,sumSore。
变量作用域
大括号作为语句块的范围,称为作用域。作用域中变量不能重复定义。离开作用域变量所分配的内存会被JVM回收。
 
数据类型转换:
byte -> short -> int ->long -> float -> double 
1.自动转换 范围小的可以直接转换为范围大的。  
2.强制转换 范围大的转换为范围小的。 int a12 = (int)a11;
 
 
运算符:
算数运算符:
+、-、*、/、%、 加减乘除取余
自增、自减、自乘、自除;
int+=1;int=int+1; int-=1; int = int - 1;
++I;先加 i++; 先运算后++;
 
赋值运算符:
= 把右边的值赋值给左边的变量;
 
比较运算符:
>、<、>=、<=、!=、==  大于、小于、大于等于、小于等于、不等于、等于
 
逻辑运算符:
& 与 两边都为true 结果为true
| 或 有一遍为true 结果为true
^ 异或 true ^ false 结果True 两边相同为false
!  非 取反 不为true 结果为true
&& 短路与 一边是false ,另一边不运行 效率高于一个的
|| 短路或 一边是true,另一边不运行 效率高于一个的
 
三元运算符:
(布尔表达式) ? (真结果1) : (假结果2)    3>1?’big’:’small’;
 
Scanner类
在命令行中接受键盘输入
1.引入包 import java.util.Scanner;
2.实例化 Scanner sc = new Scanner(System.in);
3.使用方法 sc.nextInt(); 接受输入的整数 sc.next();接受输入的字符串
 
Random类
产生随机数
1.引入包 import java.util.Random;
2.实例化 Random  r = new Random();
3.使用 r.nextInt(99); //范围 生成一个随机数
 
流程控制语句
IF语句 如果满足某个条件 就执行 
    If(1==1 || 2 ==2){
    }else if(1 != 1 && 1 != 3){
    }else{
    }
Swtich语句 
    switch(a){
        Case 1:
        case 2:
        Break;
         Default:
        Break;
    }
 
循环语句
while循环 先判断再循环 条件为真就循环
While(I<5){
    I++;
}
 
do..while循环 先执行再判断
do{
}while(true);
 
for循环  
指定次数的循环
for(int I = 1;i<10;i++){
}
 
break语句
停止循环
 
continue语句
结束本次,继续下次循环。
 
数组:
数据类型[] 数组名 = new 数据类型[元素个数];
下标从0开始,最大值长度-1.超出报错。
int [] nums = new int[3];
nums[2] = 1;
 
//定义的同时对数据进行赋值
int[] arr = new int[]{1,2,3,4,4};
int[] arr= {1,2,3,4,5}; //简化版
 
//遍历数组
for(int I= 0;i<arr.length;i++){
    System.out.println(arr[i]);
}
 
二维数组:
//二维数组中有三个一纬数组
//三个一纬数组的长度是四
int[][] arrs = new int[3][4];
arrs[0][0] = 1;
System.out.println(arrs[0][0]);
 
int[][] arrs = {{1,2,3,4,5},{1,2,3,4,5}};
for(int i = 0;i<arrs.length;i++){
    for(int j = 0;j<arrs[i].length;j++){
        System.out.println(arrs[i][j]);
    }
}
 
方法:
修饰符 返回值类型 方法名(参数1,参数2,……){
    return 返回值;
}
返回值的结果要与返回类型一致。
public static void main(String[] args) {
    System.out.println(sayHi());
}
public static String sayHi(){
    return "Hi";
}
 
 
方法的重载:
在同一个类中,方法名一致,参数列表不同即可。
public static void main(String[] args) {
    System.out.println(sayHi("david"));
}
public static String sayHi(){
    return "Hi";
}
public static String sayHi(String name){
    return name + "Hi";
}
 
方法中参数是基本数据类型:
方法内改变值不影响原值。
 
方法中参数是引用数据类型:
方法内改变值影响原值。
 
类:
public class 类名{
    属性定义
        修饰符 数据类型 = 值;
    方法定义
        修饰符 返回值类型 方法名(参数列表){
        }
}
 
public class Phone {
    public int Size = 14;
    public String Color = "Red";
    public String Call(String number){
        return "正在呼叫:"+number;
    }
}
 
public static void main(String[] args) {
    Phone p = new Phone();
    System.out.print(p.Call("13845054318"));
    p.Size = 100;
    System.out.print(p.Size);
}
 
 
ArrayList集合
1.导入包 import java.util.ArrayList;
2.创建对象 ArrayList<数据类型> 名 = new ArrayList<数据类型>();
数据类型不能是基本数据类型,必须是引用数据类型。
byte -> Byte
short -> Short
Int -> Integer
long -> Long
float -> Float
double -> Double
char -> Character
boolean -> Boolean
 
常用方法:
Add() 添加元素
Get() 取出元素 索引取出
size() 返回长度 
Set() 修改指定索引的元素
remove() 移除指定索引的元素
Clear() 清空
 
ArrayList<Integer> nums = new ArrayList<Integer>();
nums.add(1);
nums.add(3);
nums.add(3);
nums.add(3);
nums.add(3);
for(int i = 0;i<nums.size();i++){
    System.out.println(nums.get(i));
}
 
面向对象
三大特性:封装、集成、多态。
 
封装:隐藏具体实现的细节,对外提供可以访问的方式。便于调用者的使用。提高了复用性。
 
private 私有的 
get、set方法
public class Phone {
    private int size;
    public void setSize(int s){
        size = s;
    }
    public int getSize(){
        return size;
    }
}
 
this关键字
    区分成员变量和局部变量同名的情况
this.size为属性 
public class Phone {
    private int size;
    public void setSize(int s){
        int size = 1;
        this.size = s;
    }
    public int getSize(){
        return this.size;
    }
}
 
继承:子类自动拥有父类所有可继承的属性和方法。
class 子类 extends 父类{}
单继承,一个类只可以有一个父类
方法重写:子类方法名与父类一致,参数也一致。调用时如果子类有就调用子类的没有再调用父类的。
 
抽象类:
public abstract 返回值类型 方法名(参数){}
抽象类不能被创建对象,因为抽象方法没有意义。
抽象类一定是个父类,如果没有子类重写他的方法,那么他将没有意义。
public abstract class Phone {
    //抽象函数 没有方法体
    public abstract void Call();
}
public abstract class Iphone extends Phone {
    public void Work(){
        System.out.println("abstract");
    }
}
 
接口:
接口最主要的是用来解决多继承的弊端,将多继承这种机制在java中通过实现完成了。
public interface 接口名{
    抽象方法1;
    抽象方法2;
}
接口中的方法不能有方法体,属性必须为常量。方法可以不写public abstract
public interface Iphone{
    //常量
    public static final int Age = 18;
    //抽象方法
    public abstract void SayHi();
}
实现一个接口使用关键字implements,并且实现接口的全部方法。
public class Phone implements Iphone{
    public void SayHi(){
        System.out.print("接口"+ this.Age);
    }
}
多实现:
A implements  B,C
 
在一个类中可以同时继承并且实现多个接口
A extends B implements C,D
 
多态:
对象在调用同一个方法时表现出来的多种状态。
如:你在vs中按f1出现vs的帮助文档,在idea中按f1则会出现idea的使用帮助。
 
多态的三个必要条件:继承、重写、父类引用指向子类对象
 
父类类型或者接口类型  变量 = new 子类的对象();
Person p1 = new Student();
Person p2 = new Teacher();
 
instanceof关键字
比较运算符,返回真假,判断某个对象是否属于某种数据类型。
boolean result = 对象 instanceof 数据类型;
 
P1 instanceof Student(); //true
p2 instanceof Student(); //false
 
转型
向上转型:当有子类对象复制给一个负累引用时,就是向上转型,多态本身就是向上转型的过程。
向下转型:将负累引用转换为子类引用。强制转换。
Student stu =(person) p1;
 
构造方法:
创建对象时,初始化对象。 构造方法没有返回值类型。
如果没有自定义构造函数,系统会有一个默认无参的构造函数。
public class Person {
    private String name;
    private int age;
 
    Person(String name,int age){
        this.name = name;
        this.age = age;
    }
 
    public void SayHi(){
        System.out.println("我叫:"+this.name+";我今年:"+this.age+"岁了");
    }
 
}
 
public static void main(String[] args) {
    Person p = new Person("david",18);
    p.SayHi();
}
 
this关键字
可以在多个构造方法之间调用
public class Person {
    private String name;
    private int age;
 
    Person(String name){
        this.name = name;
    }
 
    Person(String name,int age){
        this(name);
        this.age = age;
    }
 
    public void SayHi(){
        System.out.println("我叫:"+this.name+";我今年:"+this.age+"岁了");
    }
 
}
 
super关键字
在创建子类对象时,父类的构造方法会先执行,因为子类中所有构造方法的第一行有默认的隐式super();语句。
使用super(实参列表) 可以调用父类中的构造方法。
public class Chinese extends Person {
    Chinese(String name,int age){
        super(name,age);
    }
}
public class Main {
    public static void main(String[] args) {
        Chinese c = new Chinese("david",18);
        c.SayHi();
    }
}
 
final 不可变
可以用来修饰类,类的成员,以及局部变量。
final修饰的类 不可以被继承,但是可以继承其他类。
final修饰的方法 不可以被子类重写。
final修饰的变量 称为常量,不会改变的值。
 
static 静态的
静态的方法可以直接 类名.方法名调用 不需要实例化
public class tai {
    public static void SayTai(){
        System.out.println("崩卡崩卡");
    }
}
tai.SayTai();
静态不能调用非静态。
 
匿名对象
new person().say(); 只用一次
 
内部类
在一个类的内部定义一个类,成为内部类。
内部类可以访问外部类所有成员,哪怕是私有的。
// 外部类
public class Outer {
    private String haha = "哈哈大笑";
    //内部类
    public class Inner{
        public void HAHA(){
            System.out.println(haha);
        }
    }
}
 
//访问方式 外部类名.内部类名 变量名 = new 外部类名().new 内部类名();
Outer.Inner inner = new Outer().new Inner();
inner.HAHA();
 
 
局部内部类
方法中的内部类
public void out(){
     class Inner{
        public void inner(){
            System.out.println("内部类方法");
        }
    }
    Inner in = new Inner();
     in.inner();
}
调用out()方法时,自动调用内部类中的方法
 
匿名内部类
new interface(){ //实例化接口 实现接口方法
    Public void smoking(){
    }
}.smoking();
 
java中的包,其实就是电脑中的文件夹,包中方的是类文件。
命名规则,全部小写,域名反写、com.xxx.web
package david.web; 包的声明 在第一行
导入包
import david.web.Outer; 具体到类名
 
修饰符
public、private、protected、default
1.仅能在本类中使用 private
2.本包中的类可以访问不加修饰符
3.本包中的类与其他包中的子类可以访问 protected
4.所有包中的所有类 public
一个文件中只能有一个public修饰的类,如果用public修饰则类名必须与文件名相同。
 
API
java为我们封装好的一些类,直接使用即可。
 
Object
object是所有类的父类,object所有的方法,子类都能使用。
 
equals
比较两个对象是否相同。
 
toString()
返回该对象的字符串表示。
 
String类
字符串字面值是String其实是类的实例。
字符串一旦创建,字符串本身不能改变,但str变量中记录的地址是可以改变的。
String str = "abcdefghijklmnopq123456";
String str2 = new String("abcdefghijklmnopq123456");
System.out.println(str == str2); //false 引用类型数据,==比较的是对象的地址
System.out.println(str.equals(str2)); //true equals 比较的是对象的内容
 
常用方法:
length()  返回字符串长度 字符个数
substring(startIndex,endIndex) 截取字符串 返回从开始到结束的字符串
startsWith(String prefix) 检测是否以此字符串开头
endsWith(String suffix) 检测是否以此字符串结尾
contains(String str) 判断字符串是否包含str字符串
indexOf(String str) 返回制定字符串在字符串中第一次出现的索引 没有返回-1
getBytes() 返回byte数组
toCharArray() 返回字节数组
equals(object obj) 字符串与指定对象比较
equalsIgnoreCase() 比较字符串不考虑大小写
toUpperCase() 转换大写
toLowerCase() 转换小写
replace() 替换字符串,使用的字符串
Split() 参数分隔符 返回字符串数组
 
StringBuffer类
字符串缓冲区支持可变的字符串。
StringBuffer sb = new StringBuffer();
sb.append("开头"); //追加内容
sb.append("中间");
sb.insert(0,"在0插入");
//"在0插入开头中间";
sb.delete(1,4); //删除索引1到4的字符串
//在开头中间
sb.reverse(); //反转
System.out.println(sb.toString());
StringBuffer是线程安全的,所以速度慢一些。
StringBuilder 不是线程安全的,所以比较快。
 
正则表达式
用来定义匹配规则,检查一个字符串是否符合该规则。
\\ 转义\
\n 换行
\r 回车
[abc] 范围abc中有一个即可
[^abc] 取反 不能有abc中的一个
[a-zA-Z] 小写a到z及大写A-Z中任何一个都可以
[0-9] 匹配数字0到9之内
[a-zA-Z_0-9] 匹配字母下划线数字
预定义字符:
\d 相当于0-9
\w 相当于a-zA-Z
^ 代表的是行的开头
$ 代表的是行的结尾
\b 单词边界
? 一次或一次也没有
* 0次或多次
+ 一次或多次
{n} 正好n次
{n,} 至少n次
{n,m} 至少n次,最多m次。
 
字符串.matches(regex) 返回真假
public static boolean checkQQ(String qq){
    boolean result = qq.matches("^[1-9][0-9]{4,9}$");
    return result;
}
邮箱验证
String email = "abc123@sina.com.cn";
boolean checkEmail = email.matches("[a-zA-Z0-9_]+@[a-zA-Z]+(\\.[a-z]+)+");
System.out.print(checkEmail);
 
str.split(regex); 根据正则切割
String str = "192.168.0.2";
String[] strs = str.split("\\.+");
for(int i =0;i<strs.length;i++){
    System.out.println(strs[i]);
}
 
str.replaceAll(regex) 根据正则替换
String str = "192.168.0.2";
str = str.replaceAll("\\.","*");
System.out.print(str);
 
Date类
时间原点:公园1970年1月1日,午夜0点。 毫秒值是0;
System.currentTimeMillis() 到今天的毫秒数
 
import java.util.Date;
Date date = new Date();
date.getTime(); //返回当前毫秒值
date.setTime(1521877860868L); //设置日期通过毫秒值
System.out.print(date);
 
日期格式化
import java.text.SimpleDateFormat;
 
SimpleDateFormat pattern = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date = pattern.format(new Date());
System.out.println(date);
 
字符串转成Date对象
//有可能转换失败,所以要加异常。需要完全匹配规则
public static void main(String[] args) throws ParseException {
    SimpleDateFormat pattern = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    Date date = pattern.parse("1995-12-1 12:12:12");
    System.out.println(date);
}
 
Calendar日历类
抽象类,替换了很多Date中的方法。
Calendar.getInstance(); 获取默认时区和语言环境获得一个日历。
 
get() 方法 获取日历字段
Calendar c = Calendar.getInstance();
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH)+1;
int day = c.get(Calendar.DAY_OF_MONTH);
System.out.println(year+"-"+month+"-"+day);
 
Set() 方法 设置日历字段
Calendar c = Calendar.getInstance();
c.set(Calendar.YEAR,2088);
c.set(2099,4,5);
c.set(2099,4,5,12,30,0);
 
add() 方法 
c.add(Calendar.DATE,5); 添加5天
c.add(Calendar.DATE,-5); 减少5天
 
活了多少天
Calendar my = Calendar.getInstance();
Calendar c = Calendar.getInstance();
my.set(1991,0,11);
long day = c.getTimeInMillis();
long myDay = my.getTimeInMillis();
System.out.println((day-myDay)/1000/60/60/24);
 
包装类
包装类中封装了一些实用的方法和常量。
Integer类 是int类型
Integer.parseInt("123”); //将字符串转换为int类型
Int转字符串
    int num = 10;
    System.out.println(num+""+12); //加双引号
方法2:
    Integer.toString(num);
常量两个:
Integer.MAX_VALUE 最大值
Integer.MIN_VALUE 最小值
 
Byte类 是byte类型的包装类
Float类 是float类型的包装类
 
自动装箱:基本数据类型直接变成对象
Integer i = 1; //Integer i = new Integer(1); 1转换成引用各类型 装箱
自动拆箱:对象中的数据变回基本类型
i++; //自动拆箱 引用类型会转换回基本类型做运算
 
System类
System.exit(0); //终止虚拟机jvm
System.gc()
; //垃圾回收
System.getProperties(); //获取系统信息
System.arraycopy(); //复制数组
 
Math类
import java.lang.Math;
Math.abs(-9)  绝对值
Math.Max min 最大最小值
Math.pow(a,b)a的b次方
Math.random(); 随机数0.0-1.0之间
Math.round(double d) 四舍五入,取整数 
 
Arrays类
import java.util.Arrays;
Arrays.sort(arrys) 排序数组 升序
 
Arrays.binarySearch(arrys,3) 查找值,返回出现的索引
 
Arrays.toString(arrys) 输出字符串
 
BigInteger类
超大整型数据,比Long还大。
import java.math.BigInteger;
加法:
BigInteger b1 = new BigInteger("1231231231231231233123");
BigInteger b2 = new BigInteger("1231231231231231233123");
System.out.println(b1.add(b2));
 
减法:
System.out.println(b1.subtract(b2));
 
乘法:
System.out.println(b1.multiply(b2));
 
除法:
System.out.println(b1.divide(b2));
 
BigDecimal类
高精度浮点运算
import java.math.BigDecimal;
//原因:计算机二进制中,表示浮点数不精确造成。
System.out.println(0.09+0.01); //0.09999999999999999
System.out.println(1.0-0.32); //0.6799999999999999
System.out.println(1.015*100); //101.49999999999999
System.out.println(1.301/100); //0.013009999999999999
 
BigDecimal b1 = new BigDecimal("0.09");
BigDecimal b2 = new BigDecimal("0.01");
//加法
System.out.println(b1.add(b2)); //0.10
//减法
System.out.println(b1.subtract(b2));//0.08
//乘法
System.out.println(b1.multiply(b2));//0.0009
//除法 第二个参数保留几位小数,有可能除不尽的时候会报错
System.out.println(b1.divide(b2,2));//9
 
BigDecimal b3 = new BigDecimal("1.601");
BigDecimal b4 = new BigDecimal("101");
//ROUND_UP 向上+1  ROUND_DOWN 直接舍去 ROUND_HALF_UP四舍五入
System.out.println(b3.divide(b4,4));//0.016
System.out.println(b3.divide(b4,2,BigDecimal.ROUND_UP));//0.02
System.out.println(b3.divide(b4,2,BigDecimal.ROUND_DOWN)); //0.01
System.out.println(b3.divide(b4,2,BigDecimal.ROUND_HALF_UP)); //0.02
System.out.println(b3.divide(b4,2,BigDecimal.ROUND_HALF_DOWN)); //0.02
 
Collection接口
是所有集合的根接口
集合Collection接口中的方法(所有实现类必须拥有的方法)。
//接口多态的方式调用
Collection<String> co = new ArrayList<String>();
//添加元素
co.add("abc");
co.add("bcd");
System.out.println(co);//[abc, bcd]
//清空集合中的元素
co.clear();
System.out.println(co);//[]
 
contains(object o) 判断对象是否存在于集合中,存在返回true。
co.contains("abc”);
 
toArray(); 将集合转成数组
Object[] obj = co.toArray();
for(int i = 0;i<obj.length;i++){
    System.out.println(obj[i]);
}
 
remove(); 删除
co.remove("abc”); //删除第一个匹配的元素
 
Iterator接口 迭代器
Java中提供了许多集合,他们在存储时方式不同。取出时通过一种通用的方式。如果有就取出。
接口Iterator :两个抽象方法
    boolean hasNext() 判断集合中还有没有可以被取出的元素,如果有返回true。
    next() 取出集合中的下一个元素
使用ArrayList集合的对象
    Iterator it = array.iterator(); 运行结果就是Iterator接口的实现类对象
    It是接口的实现类对象,调用方法hasNext和next集合元素迭代
 
Collection<String> co = new ArrayList<String>();
co.add("abc");
co.add("bcd");
co.add("abc");
Iterator<String> it = co.iterator();
while(it.hasNext()){
    String val = it.next();
    System.out.println(val);
}
 
for写法
for(Iterator<String> it = co.iterator();it.hasNext();){
    System.out.println(it.next());
}
 
增强for循环
Jdk1.5以后出来的新特性,java.lang.Iterable。
collection(原集合根接口)开始继承Iterable。
格式:
    for(数据类型 变量名 : 数组或集合){
        System.out.println(变量名);
    }
int[] nums = {1,2,3,4,5,6,6,6,6,4,3,2,23,4};
for(int n : nums){
    System.out.println(n);
}
好处:代码少,方便遍历
弊端:没有索引,不能操作容器里面的元素
 
泛型
使用集合时,明确集合中的元素类型。不会像arrayList那样object强转异常。
 Collection<String> coll = new ArrayList<String>();
 
Java泛型是伪泛型
ArrayList<String> 编译手段
arr.add(“”) 不是String的时候编译失败
但是编译后的class文件,是没有泛型的
 
      修饰符 class 类名<代表泛型的变量> {  }
      例如,API中的ArrayList集合:
      class ArrayList<E>{
           public boolean add(E e){ }
        public E get(int index){  }
      }
 
      创建对象时,确定泛型的类型
      例如,ArrayList<String> list = new ArrayList<String>();
      此时,变量E的值就是String类型
      class ArrayList<String>{
        public boolean add(String e){ }
        public String get(int index){  }
      }
      例如,ArrayList<Integer> list = new ArrayList<Integer>();
      此时,变量E的值就是Integer类型
      class ArrayList<Integer>{
           public boolean add(Integer e){ }
           public Integer get(int index){  }
      }
 
?泛型的通配符
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
 
public class Main {
    public static void main(String[] args){
        ArrayList<Integer> nums = new ArrayList<Integer>();
        nums.add(1);
        nums.add(2);
 
        ArrayList<String> strs = new ArrayList<String>();
        strs.add("abc");
        strs.add("def");
 
        iterator(nums);
        iterator(strs);
 
    }
    public static void iterator(Collection<?> coll){
        Iterator<?> it = coll.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}
 
泛型的限定
      //创建3个集合对象
      ArrayList<ChuShi> cs = new ArrayList<ChuShi>();
      ArrayList<FuWuYuan> fwy = new ArrayList<FuWuYuan>();
      ArrayList<JingLi> jl = new ArrayList<JingLi>();
      //每个集合存储自己的元素
      cs.add(new ChuShi("张三", "后厨001"));
      cs.add(new ChuShi("李四", "后厨002"));
      fwy.add(new FuWuYuan("翠花", "服务部001"));
      fwy.add(new FuWuYuan("酸菜", "服务部002"));
      jl.add(new JingLi("小名", "董事会001", 123456789.32));
      jl.add(new JingLi("小强", "董事会002", 123456789.33));
      iterator(jl);
      iterator(fwy);
      iterator(cs);
 
//方法参数: 控制,可以传递Employee对象,也可以传递Employee的子类的对象
    public static void iterator(ArrayList<? extends Employee> array){
       Iterator<? extends Employee> it = array.iterator();
       while(it.hasNext()){
         //获取出的next() 数据类型,是什么Employee
         Employee e = it.next();
         e.work();
       }
    }
 
List接口
有序的collection,可以对每个元素的插入位置进行精确的控制,根据整数索引控制。
可以存储重复元素。
继承Collection接口,实现类ArrayList、LinkedList。
 
并发修改异常
使用迭代器遍历集合时改变集合会报错。
Iterator<String> it = co.iterator();
while(it.hasNext()){
    String val = it.next();
    if(val==“abc”)
       Co.add(“aa”); //迭代器工作时 不可以改变集合
    System.out.println(val);
}
 
LinkedList类 
import java.util.LinkedList;
对一个集合的操作如果大多是首尾操作那么推荐使用LinkedList类。
LinkedList<Integer> link = new LinkedList<Integer>();
link.add(1);
link.addLast(2);//添加到当前末尾
link.add(3);
link.addFirst(4); //添加到当前开头
if(!link.isEmpty()){ //link.size() != 0
    System.out.println(link); //[4, 1, 2, 3]
    System.out.println(link.getFirst()); //获取开头
    System.out.println(link.getLast()); //获取结尾
}
link.removeFirst();
link.removeLast();
System.out.println(link);//[1, 2]
 
Set接口
不允许存储重复元素,取出可以使用迭代器、增强for。没有索引,无序的。
继承collection,实现类hashSet。
HashSet<String> set = new HashSet<String>();
set.add("haha1");
set.add("abc2");
set.add("def3");
set.add("ghi4");
 
for(String s : set){
    System.out.println(s);
}
如果存入重复的,只存进去一个。
 
Map接口
键值对集合,不能重复key,常用集合为HashMap集合、LinkedHashMap集合。
HashMap<Integer,String> map = new HashMap<Integer,String>();
//添加键值对
map.put(1,"a");
map.put(2,"b");
map.put(1,"c"); //key重复 会覆盖原有value
System.out.println(map);//{1=c, 2=b}
 
String val = map.get(1); //get通过key获取value
System.out.println(val); //c
 
map.remove(1); //移除
 
//返回set keySet()返回所有key
Set<Integer> keys = map.keySet();
 
for(int i : keys){
    System.out.println(i+":" +map.get(i));
}
 
Entry 键值对对象
Entry将将只对的对应关系封装成了对象,在遍历map集合时,就可以从每一个键值对Entry对象中获取对应的key与value。
//返回set entrySet()返回所有entry对象
Set<Map.Entry<Integer, String>> entrys = map.entrySet();
 
for (Map.Entry<Integer, String> entry : entrys) {
    System.out.println(entry.getKey() + ":" + entry.getValue());
}
 
HashTable 线程安全集合,运行速度比较慢 不允许存null key,null value
HashMap 线程不安全集合,运行速度快 可以存null key,null value
 
静态导入
import static XXX.YYY;   导入后YYY可直接使用
import static java.util.Map.Entry;
        //for (Map.Entry<Student, String> entry : entrySet) {
        for (Entry<Student, String> entry : entrySet) {
 
可变参数
前提:方法参数的数据类型需要确定,参数的个数不确定。
修饰符 返回值类型 方法名(参数类型… 参数名)
public static void main(String[] args) {
    System.out.println(getSum(4,5,3,2,5,9));
}
public static int getSum(int... nums){
    int sum = 0;
    for(int i : nums){
        sum+=i;
    }
    return sum;
}
一个方法中可变参数只能有一个, 如果有多个参数,可变参数要再参数列表最后一个。
 
Collections.sort 静态方法 对List集合升序排列
List<String> list = new ArrayList<String>();
list.add("sdf");
list.add("abc");
list.add("ccsl");
System.out.println(list); //[sdf, abc, ccsl]
Collections.sort(list);
System.out.println(list); //[abc, ccsl, sdf]
 
Exception 异常
如数组越界等,程序会为使用者抛出异常,停止程序。
throw关键字
抛出一个异常。
 
异常处理:
try{
    可能出现异常的代码
}catch(异常类名 变量){
    出现异常后执行的代码
}finally{
    不管出现异常与否都执行的代码
}
 
int[] arrys = new int[]{1,2,3};
try{
    int num = arrys[3];
    System.out.println(num);
}catch (Exception ex){
    System.out.println(ex);
}finally {
    System.out.println("都会执行");
}
 
 
 

Java基础

标签:next()   类文件   with   完整   binary   spl   特性   重写   face   

原文:https://www.cnblogs.com/baidawei/p/8665283.html

技术交流学习或者有任何问题欢迎加群

编程技术交流群 : 154514123 爱上编程      Java技术交流群 : 6128790  Java

广告推荐

讨论区