java编程规范-->变量（基本和引用数据类型）-->运算符-->循环语句-->函数（构造函数和非构造函数）-->调用函数-->外部jar包调用-->常用集合类（list map set）-->java三大特性（封装 继承 多态）-->修饰符权限
-- java语言的简单介绍
Java是一门后台开发语言
思想是:面向对象
java一般是用在web系统开发，以及app后台服务器开发
用java开发系统的特点：跨平台,安全性高
-- 设置工作区间编码
window--》preference--》workspace--》--》utf-8--》java project--》package--》class--》main
包：package是为了更好的管理我们的类,以多个点号.作为分隔
类名：尽量不能中文，大写字母开头，驼峰命名
src：原文件
bin：被编译后的class文件
jre：属于jdk一部分，java运行环境,配置在jdk下的jre，方便查找源文件 java runtime environment
jdk：java development kit
main函数，程序执行的入口，语法
public static void main(String[]args){
System.out.println("Hello World");
}
-- 注释
类的注释
/***/shift+alt+j
代码注释
单行注释和取消//ctrl+/
多行注释/**/ctrl+shift+/
多行注释取消ctrl+shift+\
删除ctrl+d
撤回ctrl+z
撤销ctrl+y
保存ctrl+s
关键字：有特殊含义的，紫色，ctrl+点击关键字可以查看对应源代码
-- java代码执行的原理
java文件-java编译器编译成class文件-类加载加载到我们的虚拟机jvm-虚拟机解释器会执行我们的代码
-- 类与对象
类:共性事物的抽象，是对某一类具有共性事物的描述，是概念上的定义（狗类）
对象:对象是共性事物的体现，是这类事物的每个个体，或者类的实例（哈士奇，金毛，等）
总结:类是对象的模板，对象是类的实例
-- 类的组成
变量
函数(方法)
-- 变量
变量是用于存储数据的,int x=4;
int 是变量的类型，在java语言中任何数据都是有类型的，所以变量前面需要声明一个变量类型
-- 变量分类
基本数据类型
引用数据类型
-- 基本数据类型,4类8种
1,逻辑类型,boolenan(布尔类型ture/false)
2,整型,byte(字节型,占用一个字节)/short(短整型,占用两个字节)/int(整型,占用四个字节)/long(长整型,占用八个字节)
一个字节占八位
3,浮点型,float(单精度浮点型,占用四个字节)/double(双精度浮点型,占用八个字节)
4,字符型,char(字符型)，赋值的时候数据长度只能是一位，并且用单引号包起来''
boolean aa=true;
byte bb=3;
short cc=4;
int dd=5;
long ee=6;
float ff=7.1f;
double gg=7.2;
char hh='a';
-- 引用数据类型
引用类型的变量是一个内存地址，一个位置信息（就相当于门牌号）
-- 引用类型分类
1,数组
2,类
3,接口
4,枚举
-- 引用类型-字符串String
String a="HelloWorld"
字符串类型的变量一般用于存储一串文字信息
字符串可以跟任意类型的数据进行拼接得到新的字符串，拼接符号为"+"
"Hello"+"World"
"Hello"+1234
public static void main(String[]args){
String a="Hello";
String b="World";
System.out.print(a+b);
}
-- 引用类型-数组类型
数组是一种数据结构，它是一个容器，用来盛放数据，不同类型的数组可以盛放不同类型的数据
-- 数组的特点
数组的容量是确定的，也就是定义数组的时候必须定义数组的大小
数组的类型是确定的，也就是定义数组的时候必须定义数组的类型，一种类型的数组只能放一种类型的数据
-- 数组的分类
1,一维数组,
2,多维数组,
-- 创建一维数组语法
创建一个数组，但是没有初始化数组的元素，这种情况需要显示指定数组的大小
数据类型[]数组名=new 数据类型[size];
实例：int[]myArr=new int[3];
创建一个数组，并已知数组的内部元素
数据类型[]数组名={};
实例：int[]myArr={0,1,2,};
eg
数据类型[]数据名=new 数据类型[size]
int[]aa=new int[n];不知道数组的时候，通过索引进行赋值，索引从0开始，
String []arr3=new String[3];
arr3[0]="Hello";
arr3[1]="World";
arr3[2]="java";
System.out.println(arr3[0]+arr3[1]+arr3[2]);
int[]aa={1,2,3,4,5};知道数组的时候
-- 运算符，基础分类
算数运算符
关系运算符
逻辑运算符
赋值运算符
其他运算符
-- 算数运算符 +，-，*，/,%,++,-- 加/减/乘/除/模余/自增/自减
public static void main(String[]args){
int a=1;
int b=2;
System.out.println("a+b="+(a+b));
System.out.println(b-a);//1
System.out.println(a*b);//2
System.out.println(b/a);//2
System.out.println(a/b);//0
System.out.println(a%b);//1,商0余1
System.out.println(b%a);//0,商2余0
++a;//2
//System.out.println(++a);//3，先自增，在输出a
System.out.println(a++);//2,先输出a，在自曾
b--;//1
//System.out.println(--b);//0,先自减，在输出b
System.out.println(b--);//1,先输出吧，在自减
}
-- 关系运算符 ==,!=,>,<,>=,<=
只运用在数值类型数据间的运算，运算结果是布尔类型的值
public static void main(String[]args){
int a=1;
int b=2;
System.out.println(a>b);//false
System.out.println(a==b);//false
}
-- 逻辑运算符 &，&&，丨，丨丨，！，逻辑与/短路与/逻辑或/短路或/逻辑非
只运用于boolean类型的数据之间的运算
逻辑与：当且仅当两边运算符都为真时，最后运算结果才为真；
短路与：当且仅当两边运算符都为真时，最后运算结果才为真；前面结果为假时，则后面表达式不会执行；
逻辑或：如果两个操作数任何一个为真，则返回真；
短路或：如果任何两个操作数任何一个为真，条件为真，但是值得注意的是，前面表达式为真时，则后面表达式不会执行；
public static void main(String[]args){
int a=1;
int b=2;
int c=3;
System.out.println((a>b)&(b>c));//false
System.out.println((a>b)&&(b>c));//false
System.out.println((a>b)&&(++b>c));//false,
System.out.println(b);//2,短路与没有计算后面表达式，自增
System.out.println((a<b)|(b<c));//ture
System.out.println((a<b)||(b<c));//ture
System.out.println((a<b)||(++b<c));//ture
System.out.println(b);//2,短路与没有计算后面表达式，自增
System.out.println(!(a>b));//ture
}
-- 赋值运算符 =，+=，-=，*=，/=,(%)=,赋值/加和赋值/减和赋值/乘和赋值/除和赋值/模余和赋值
public static void main(String[]args){
int a=1;
int b=2;
int c=3;
a+=b;
System.out.println(a);//3
a-=b;
System.out.println(a);//1
a*=b;
System.out.println(a);//2
a/=b;
System.out.println(a);//1
a%=b;
System.out.println(a);//1
}
-- 其他运算符，条件运算符（?:）三目运算符
表达式1？表达式2：表达式3
表达式1，结果为true，执行表达式2，结果为false，执行表达式3
public static void main(String[]args){
int a=1;
int b=2;
int c=3;
System.out.println(a==b?"等于":"不等于");//不等于
System.out.println(a==b?++a:--b);//1
}
-- 运算顺序
1,++,--
2,括号
3,*,/,%(同一优先级，从左至右)
4,+,-(同一优先级，从左至右)
注意：
1,同一优先级运算符顺序为，从左至右
2,复杂运算符要一步步拆解运算
-- 多维数组
[a][b]
a:代表外层数组的容量
b:代表每一个内层数组的容量
{{},{},{}};
int[][]arr1=new int[3][];//未定义内层数组数
int[][]arr2=new int[3][2];//定义内层数组数
int[][]arr3={{1,2},{3,4,5},{6,7,8,9}};//明确数组值
arr2[0][0]=1;
arr2[0][1]=2;
arr2[1][0]=3;
arr2[1][1]=4;
arr2[2][0]=5;
arr2[2][1]=6;
//先声明每一个数组的容量，才能操作数组赋值
arr1[0]=new int[5];
arr1[1]=new int[2];
arr1[2]=new int[2];
arr1[0][0]=1;
arr1[0][1]=2;
arr1[0][3]=2;
arr1[1][0]=3;
arr1[1][1]=4;
arr1[2][0]=5;
arr1[2][1]=6;
System.out.println(arr1[0][0]);
-- 循环语句for
语法for（初始值；循环条件；自增）{循环体}
for(int i=1;i<=10;i++){
System.out.println(i);
}
初始值；循环条件；循环体代码
求和
int result=0;
for(int i=1;i<=10;i++){
result+=i;
}
System.out.println(result);//55
多重循环
for(int i=1;i<=5;i++){
for(int j=1;j<=2;j++){
System.out.print(j);//12
}
System.out.println();
}
增强式for循环
int[]a={1,2,3,4,5};
for(int i=1;i<=a.length;i++){//通过a.length表示集合长度
System.out.print(a[i-1]);
}
System.out.println("=======");
for(int variable:a){
System.out.print(variable);
}
增强式for循环
使用快捷键fore可以把最近的for循环转化为增强式for循环
String[]bb={"Hello ","World ","Xiao ","Zhou"};
for(String abc:bb){
System.out.print(abc);
}
循环控制
continue跳过本次循环
int[]a001={1,2,3,4,5};
for(int i:a001){
if(i==4){
continue;
}
System.out.print(i);
}
break结束本次循环
int[]a001={1,2,3,4,5};
for(int i:a001){
if(i==4){
break;
}
System.out.print(i);
}
-- while循环语法
do{}while(条件1);先执行在判断条件，循环体的代码至少执行一次
while（条件2）；只有满足的时候才会执行,不满足不执行循环
public static void main(String[]args){
int x=1;
do{
System.out.println(x);//1,2,3,4,5
x++;
} while(x>=1&x<=5);
}
public static void main(String[]args){
int x=0;
while(x>=0&x<=5){
x++;
System.out.println(x);//1,2,3,4,5,6
}
}
-- 常见的条件控制语句
switch语句
if...else...语句
if...elseif...else语句
if...if...if...语句
-- switch(变量a){
case a：
.....;
break;
case b：
.....;
break;
...........
default:
.....;
break;
}
语法详解：
switch有轮换的意思，针对switch里的变量a去匹配所有的case值，若匹配则执行相关的case下的代码逻辑
case代表一种情形
":"冒号表示若符合此种情形，后面就是要执行的代码
break，有打破的意思，这里表示不再往下执行ult:：表示若前面都没有满足条件时，将要执行的代码
switch语句能接受的变量是有限的，也就是说只能是以下类型
switch中case的常用类型：char,byte,short,int,String,enum(枚举)
defa
例如switch：
//break关键字可用于循环，switch语句中打破循环
public static void main(String[]args){
byte month=1;
switch(month){
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;
case 8:
System.out.println("秋季");
break;
case 9:
System.out.println("秋季");
break;
case 10:
System.out.println("冬季");
break;
case 11:
System.out.println("冬季");
break;
case 12:
System.out.println("冬季");
break;
default:
System.out.println("找不到对应的季节");
break;
}
例如if..else
public static void main(String []args){
int a=1;
int b=9;
if(a+b>=10){
System.out.println("大于等于10");
}else{
System.out.println("小于10");
}
}
例如if..else if..else语句（满足就不执行，效率更高）
public static void main(String []args){
int a=1;
int b=9;
if(a+b>10){
System.out.println("大于10");
}else if(a+b==10){
System.out.println("等于10");
}else{
System.out.println("小于10");
}
}
int mouth=1;
if(mouth>=1&mouth<=3){
System.out.println("春季");
}else if (mouth>=4&mouth<=6){
System.out.println("夏季");
}else if(mouth>=7&mouth<=9){
System.out.println("秋季");
}else{
System.out.println("冬季");
}
例如if...if...if...(每一个if都会执行)
public static void main(String []args){
int a=1;
int b=10;
if(a+b>10){
System.out.println("大于10");
}
if(a+b==10){
System.out.println("等于10");
}
if(a+b<10){
System.out.println("小于10");
}
}
-- 变量按照数据类型区分：
基本数据类型变量
引用数据类型变量
-- 变量按照作用域区分：
局部变量
-- 局部变量特点：
没有修饰符
定义在函数内部（函数参数，或者函数体内）
作用域只限于对应的函数，在函数体外访问不到此变量，一旦此函数执行完，则这个变量就消亡了
-- 全局变量特点：
有修饰符（public，protected，默认修饰符，private）公共的，受保护的，默认的，私有的
函数外部
作用域为整个类，只有类消亡的时候，全局变量才会消亡
注意：
在同一个作用域内不能定义相同名字的变量
当一个变量为全局并且局部也有时，访问函数取函数内的局部变量
例子1
private int a=1;
private String b="hello";//a,b是全局变量，在函数外部
public static void main(String[]args){//函数
int c=1;
String d="world";//c,d是局部变量
}
例子2
static int a=1;//静态的，变量才能被函数访问
private String b="hello";//a,b是全局变量
public static void main(String[]args){//静态函数访问全局变量必须是静态的
int c=1;
String d="world";//c,d是局部变量
System.out.println(c);
System.out.println(a);//访问全局变量
}
-- 函数概念分类及语法：
概念：定义在类中的具有特定功能的一段独立小程序，函数也称为方法
分类：函数的基本分类：构造函数；非构造函数（普通函数）
语法：修饰符+函数返回值类型+函数名（参数类型 参数名...）{函数体}
-- 非构造函数：
修饰符+函数返回值类型+函数名（参数类型 参数名...）{函数体}
public int getPassword(String name){
return 123456;
}
修饰符：public，protected，默认修饰符，private（公共的，受保护的，默认的，私有的）
函数返回值类型：基本数据类型/引用类型/空类型（void）（空类型不需要返回数据，其他类型返回对应数据）
函数名：随便定义，语法要求第一个字母小写，函数名要见名知意
参数:基础类型/引用类型
当需要从外部接收数据时定义参数，
例子1：public static void main(String[]args){}
例子2：
private int price;
private String brand;
public int getPrice(){
return this.price;
}
例子3：
public void setBrand(String brand){
//非构造函数语法：修饰符+函数返回值为空类型+函数名（需要接收数据就要定义参数/不需要就不定义）{函数体}
this.brand=brand;
-- 构造函数（没有函数返回值类型）
分类：无参构造函数（默认构造函数）；带参数构造函数
语法：
无参构造函数：修饰符+函数名（..）{...} public Member(){}
带参数构造函数：修饰符+函数名（参数类型 参数名..）{...} public
区别：构造函数没有函数返回值，类名限制死必须和类名保持一致
-- 无参构造函数：public Car(){}
-- 带参数构造函数：public Car(String brand,int price){}
例子1：对象.属性拿到属性值方法
public Car(String brand,int price){//
this.brand=brand;
this.price=price;
}
public static void main(String[]args){
Car car1=new Car();//默认值null，0
Car car2=new Car("丰田",300000);//传入Car属性
String brand1=car1.brand;
int price1=car1.price;
String brand2=car2.brand;
int price2=car2.price;
System.out.println("汽车1的品牌是："+brand1+",价格是"+price1);
System.out.println("汽车2的品牌是："+brand2+",价格是"+price2);
}
函数定义了参数，在调用的时候可以传入参数，赋给对象，所以函数在需要外部传入数据时需要定义参数
对象调用函数拿属性值，对象.函数拿到属性值只适用于当前类，用调用比较适用于其他类使用对象的属性值
访问属性，调用函数都必须用对象去访问，this表示谁调用的函数就是谁
例子2：对象.函数拿到属性值的方法
public static void main(StgetBrandring[]args){
Car car1=new Car();//默认值null，0
Car car2=new Car("丰田",300000);//传入Car属性
/*String brand1=car1.brand;
int price1=car1.price;
String brand2=car2.brand;
int price2=car2.price;*/
String brand1=car1.getBrand();
int price1=car1.getPrice();
String brand2=car2.();
int price2=car2.getPrice();
System.out.println("汽车1的品牌是："+brand1+",价格是"+price1);
System.out.println("汽车2的品牌是："+brand2+",价格是"+price2);
}
例子3：对象调用函数拿属性值
public static void main(String[]args){
Car car1=new Car();//默认值null，0
Car car2=new Car("丰田",300000);//传入Car属性
/*String brand1=car1.brand;
int price1=car1.price;
String brand2=car2.brand;
int price2=car2.price;*/
String brand1=car1.getBrand();
int price1=car1.getPrice();
String brand2=car2.getBrand();
int price2=car2.getPrice();
car1.setPrice(300000);
car1.setBrand("jeep");
brand1=car1.getBrand();//调用函数获取值
price1=car1.getPrice();
System.out.println("汽车1的品牌是："+brand1+",价格是"+price1);
System.out.println("汽车2的品牌是："+brand2+",价格是"+price2);
}
-- 调用函数注意事项
-- 构造函数的调用，
1,我们通常只有在一种情况下才会去调用构造函数，那就是创建对象，调用构造函数时，
用关键子new来调用。语法为：类名 对象名=new 类名();
或者 类名 对象名=new 类名(value1,value2...);
（这里用类名来声明，是引用类型的变量Car car1 = new Car();）
2,调用带参构造函数来创建对象，可以按照我们的意愿来初始化对象的属性，而调用无参构造函数
构造出来的对象，它的所属值都是它的属性对应类型的默认值。
3,默认构造函数是自带的，编译器在编译你的java代码时，若发现你的类里面有调用无参构造函数创建对象
但是你的类里面又没有显示的声明任何构造函数，那么类编译器就会自动帮你补齐这个无参构造函数，如果
你的类里面有定义带参构造函数，那么默认构造函数就被覆盖掉了，若此时要调用无参构造函数
则必须定义无参构造函数，否则会报错
-- 非构造函数的调用，需要用到对象来调用
1,创建对象：Member member=new Member();
2,用对象调用普通函数：member.setMobilephone("123456");
-- 函数调用注意事项
1,传参：若调用的函数有参数，则必须传入参数，而且传参类型要一致，个数也要一致，没有则不需要传参
2,返回值：返回值类型要一致，int age=s.getAge();String name=s.getName();
用关键字"return"来返回。（对应返回值为空类型的函数，不需要return语句返回任何东西，
但是其实是默认一个return语句的，这个return语句比较特殊：return;）retur表示结束语句后面的语句不会执行
-- 快捷设置setget，source-Generate Getters and Setters（生成get和set方法）-select all
-- 快捷设置构造函数，source-Constructor using Fields-勾选-确定
栈：stack先进后出
堆：heap凡是通过new关键字创建的对象都是保存在堆上面的
Car car1 =new Car();
Car car2 =new Car("jeep",3000);
-- 类的调用
jdk java devenent kit java运行环境
创建对象-导入包类-调用函数返回数据初始化赋值-打印
import java.util.Date;
public class ClassCaller {
@SuppressWarnings("deprecation")
public static void main(String[] args) {
Date date=new Date();
int hour=date.getHours();
int minutes=date.getMinutes();
int seconds=date.getSeconds();
System.out.println("时钟："+hour+"，分钟："+minutes+"，秒钟："+seconds);
}
}
-- jdk里的类调用
-- 自定义类调用
-- 外部jar包里的类调用，export导出外部jar包，built path导入外部jar包、
-- 引用的包构建编译路径删除操作，点击引入的jar包右键built path-配置编译路径-libraries-选中jar包remove掉
new一个folder,取名lib，把需要导入的包粘贴到lib里面，在添加编译路径build path lib的粘贴包，
在referenced libraries下可见到包，在调用包即可
-- ctrl+shirt+o，快速去掉找不到的类
-- String类的常用API
1,trim
2,length
3,compare To
4,concat
5,endsWith
6,equals
7,equalslgnoreCase
8,indexOF
9,isEmpty
10,lastIndexOF
11,replace
12,replaceFirst
13,replaceAll
14,split
15,substring
16,toUpperCase
17,toLowerCase
18,valuesOf
-- 类的笔记
jdk:java development kit 集成了jre
一、调用jdk里的类，例子
import java.util.Date;//导包语句，util包date类
import java.util.*;//导包语句，util包全部类
public class ClassCaller {
public static void main(String[]args){
Date date=new Date();//类导入进来，在调用它的默认构造函数
int hour=date.getHours();//拿对象date调用函数.getHours
int minutes=date.getMinutes();//拿对象date调用对象.getMinutes
int seconds=date.getSeconds();//拿对象date调用对象.getSecongs
System.out.println("时钟"+hour+"分钟"+minutes+"秒钟"+seconds);
}
}
二、调用自己写类和函数，实现自己的功能个性化的设置，例子
1.调用类，调用它的默认构造函数
调用类，调用它的带参构造函数//实参（实际参数），点进去可以看到形参（形式参数）
调用的类不是当前类，必须通过导包
调用的类是当前类，不需要导包
调用父类object
调用函数可以定义数据接收，也可以不接收调用的数据
三、如何调用外部jar包的类，类的复用
第一步导出：export-jar-jar file-设置路径，打包成class文件
第二步引用：build path-Configure build path-libraries-add external jars-找到需要的jar包，导入jar包到类下面
第三步删除移除：build path-Configure build path-libraries-找到丢失的jar包-remove -apply-ok删除jar包
ctrl+shift+o，移除找不到的类快捷键，会默认生成一个导包语句
一般把jar包单独放在一个文件夹里，new-folder-文件名lib
然后选中需要的jar包-右键-add to build path,jar包会到当前类路径，不用担心jar包被移除掉了
-- 调用函数练习
public class StringAPI {
public static void main(String[] args) {
String aa=" HelloWorld ";
// String aa1=aa.trim();//调用trim函数，去掉字符串前后的空白
// System.out.println(aa);
// System.out.println(aa1);
// System.out.println(aa.length());//调用length函数，计算字符串长度
// String aa1=aa.concat("java自动化");//调用concat函数，字符串连接符
// String aa2=aa+"java自动化";//等价于“+”连接符
// System.out.println(aa1);
// System.out.println(aa2);
String bb="C:\\Users\\lenovo\\Desktop\\mysql.png";
/* if(bb.endsWith(".png")){//调用endsWith函数，判断后缀是否以指定的内容去结尾的
System.out.println("这是一个图片");
}else{
System.out.println("这不是一个图片");
}*/
// System.out.println(aa.equals(bb));//调用equals函数，判断两个变量是否一致
// String cc =new String("test");
// String dd =new String("TEST");
// System.out.println(cc.equals(dd));//调用equals函数，判断两个变量是否一致
// System.out.println(cc.equalsIgnoreCase(dd));
//调用equalsIgnoreCase函数，判断两个变量忽略大小写是否一致
// String cc="hello";
// System.out.println(cc.indexOf("llo"));//调用indexOf函数,返回索引的第一次出现位置，如果不存在，返回-1
// String cc="";
// System.out.println(cc.isEmpty());//调用isEmpty函数,判断是否为空
// String cc="abcdefgbcshbcjhj";
// System.out.println(cc.lastIndexOf("bc"));//调用indexOf函数,返回索引最后一次出现的位置
// String cc="hellollollo";
// System.out.println(cc.replace("ll", "aa"));//调用replace函数,替换字符串
// System.out.println(cc.replaceFirst("ll","aa"));//调用replaceFirst函数,替换第一个字符串
// System.out.println(cc.replaceAll("ll", "aa"));//调用replaceAll函数,替换全部字符串
// String dd="1,2,3,4,5";
// String [] arr= dd.split(",");//调用split函数,拆分字符串成数组
// for (String ele : arr) {
// System.out.println(ele);}
// String cc="helloworld";
// System.out.println(cc.substring(3));//调用substring函数，从3开始拿值
// System.out.println(cc.substring(3,5));//调用substring函数，从3开始拿值到5结束，不包含5
System.out.println("hello".toUpperCase());//调用toUpperCase函数，字符串转大写
System.out.println("HELLO".toLowerCase());//调用toLowerCase函数，字符串转小写
int dd=1;
String ff=String.valueOf(dd);//调用valueOf函数，int类型的1，返回为string类型的数据；
System.out.println(ff);
if(ff instanceof String){//判断是否为字符串
System.out.println("字符串");
}else{
System.out.println("非字符串");
}
}
-- 基本类型对应的包装类型（引用类型）
boolean--Boonlean
byte--Byte
short--Short
int--Integer
long--Long
float--Float
double--Double
char--Charctor
-- 代码格式化快捷键，选中代码ctrl+a，格式化source-format
-- 查找类的快捷键，ctrl+shirt+t；
-- 常用集合类
list-ArrayList
map--HasMap
set--HashSet
-- ArrayList
-- 迭代ArrayList
1.通过for循环来迭代
for(int i=0;i<list.size();i++){
system.out.println(list.get(i))};
2.通过增强for循环（foreach）方式来迭代
for(String string:list){
system.out.println(string)};
3.通过获取迭代器来迭代
Iterator<String>ite=list.iterator();
while(ite.hasNext()){
String ele ite.next()
system.out.println(ele)};
-- ArrayList特点
支持数据类型：引用类型
特点：
数据排序：有序
数据重复性：可重复
-- 语法
创建list对象
ArrayList list=new ArrayList();
添加数据：list.add("");
取出数据：list.get(索引);
移除数据：list.remove(索引);
获取集合大小:list.size();
判空函数: list.isempty();
判断是否包含某函数:list.contains("");
修改某个位置:list.set(索引, "");
查询数据对应的索引位置：list.indexOf("");
例子
public static void main(String[] args) {
ArrayList<String>list = new ArrayList<String>();
// System.out.println(list.size());//获取集合数据个数
list.add("hello");//添加数据
list.add("world");
// System.out.println(list.size());//获取集合数据个数
// list.get(0);//通过索引拿第一个数据
// list.get(1);//通过索引拿第二个数据
// System.out.println(list.get(0)+list.get(1));//打印集合数据
// System.out.println(list.isEmpty());//判断集合是否为空，空为ture，非空为false
// System.out.println(list.contains("hello"));//判断集合是否包含某数据,存在返或ture
// list.set(0, "HEllo");//修改集合对应索引位置上的数据
// System.out.println(list.get(0));//打印修改后对应索引上的数据
// String ele=list.remove(0);//根据元素索引，删除对应索引上的数据，赋值给新ele元素并打印
// System.out.println(ele);
// boolean isRemoved =list.remove("hello");//根据元素是否包含某数据，去删除
// System.out.println(isRemoved);
// list.removeAll(list);//全部删除集合数据
// System.out.println(list.size());//打印集合数据个数
System.out.println(list.indexOf("hello"));//拿到索引的位置
for (int i = 0; i < list.size(); i++) {//for循环拿集合数据
System.out.println(list.get(i));
}
for (String string : list) {//增强for循环拿集合数据
System.out.println(string);
}
System.out.println("================");
Iterator<String>iterator=list.iterator();//迭代器terator拿集合数据，
while(iterator.hasNext()){//while满足条件时循环，使用迭代器的函数hasNex，有数据返或ture
String ele=iterator.next();//迭代器的函数Next,拿到每个集合数据
System.out.println(ele);
}
}
-- set--HashSet
-- HashSet特点
支持数据类型：引用类型
特点：
数据排序：无序
数据重复性：不可重复
public static void main(String[] args) {
HashSet<String>set=new HashSet<String>();//创建集合对象
System.out.println(set.isEmpty());//判断集合是否为空
set.add("hello");//添加集合数据
set.add("world");//添加集合数据
set.add("test");//添加集合数据
// System.out.println(set.isEmpty());//判断集合是否为空，ture表示为空
// System.out.println(set.contains("hello"));//判断集合中是否包含某数据
// Object []objects= set.toArray();//取数据,由于是无序数据，需要先转化为数组，在通过索引取数据
// String aa=(String)objects[0];
// String bb=(String) objects[1];
// String cc=(String)objects[2];
// System.out.println(aa+bb+cc);
// System.out.println(set.size());//获取数据个数。不统计重复数据
// String [] arr=new String[3];//取序列的数据，把序列转为数组的第二种方法，创建新数组，在使用toarray
// set.toArray(arr);//将集合数据存到数组
// System.out.println(arr[0]+arr[1]+arr[2]);
// set.remove("test");//移除数据
// set.removeAll(set);//移除所有数据
// System.out.println(set.size());
// for (String ele : set) {
// ele="ss";
// System.out.println(ele);
// }
// System.out.println("---------------");
// for (String string : set) {
// System.out.println(string);
// }
// set.removeAll(set);//通过先删除在赋值，去给set集合赋值
// set.add("ss");
// set.add("ss");
// set.add("ss");
// for (String string : set) {
// System.out.println(string);
//
// }
Iterator<String>iterator=set.iterator();//迭代器
while(iterator.hasNext()){//hasnext如果存在，取数据next
System.out.println(iterator.next());
}
}
-- Map--HashMap
-- HashMap特点
支持数据类型：引用类型
特点：
以键值对的形式来保存
键值不可重复，重复时，后者的键值覆盖前者
-- 语法
添加数据：map.put("键","值");
取出数据：map.get("键");
移除数据：map.remove("键");
获取所有的键：map.keyset();
获取所有的值：map.values();
其他API:
Map.size();
map.containsKey("键");
map.containsValue("值");
例子
public class HashMapDemo {
public static void main(String[] args) {
HashMap<String, String>map=new HashMap<String, String>();//创建对象
System.out.println(map.size());//打印数据数量
map.put("name", "张三");//添加数据
map.put("age", "21");//添加数据
// System.out.println(map.size());//打印数据数量
// Boolean isExist =map.containsKey("name");//判断是否包含某数据的键
// System.out.println(isExist);//打印结果
// System.out.println(map.containsValue("张三"));//判断是否包含某数据的值并打印
// String value=map.get("name");//.get获取数据并打印，根据key值获取
// System.out.println(value);
// map.put("name", "张三三");//修改数据，根据key值修改
// System.out.println(map.get("name"));//打印修改后的key对应的value值
map.remove("name");//删除数据
// System.out.println(map.containsKey("name"));
// System.out.println(map.get("name"));
// Set<String>keys=map.keySet();//.keySet获取所有的key值，建立数组在打印每个数组值
// for (String key : keys) {
// System.out.println(key);
// }
// Collection<String>collection=map.values();//.values获取所有的values值，collection集合类
// for (String value1 : collection) {
// System.out.println(value1);
// }
//遍历键值对
// Set<String>keys=map.keySet();//获取所有的键
// for (String key : keys) {//获取集合里的键
// String value=map.get(key);//根据键获取值
// System.out.println("key="+key+",values="+value);//打印键值结果
// }
Set<java.util.Map.Entry<String, String>> entrySet=map.entrySet();
//set集合，里面存放的是键值对
for (java.util.Map.Entry<String, String> entry : entrySet) {
System.out.println("key="+entry.getKey()+",value="+entry.getValue());
}
-- java三大特性
封装，继承，多态
-- 24继承
java的三大特性之一，声明了继承关系的两个类，子类可以继承父类的特性和行为，
这样子类就具有了父类相同的行为和属性
我们也可以把子类称为派生类，从父类派生而来
-- 继承语法extends
public class 父类{}
public class extends 父类{}
-- 为什么要继承
它是一种非常好的设计模式和特性，因为解决了很多问题
1.代码更简洁，优雅
2.代码的维护性好
3.代码的复用性高
-- 继承的其他特性
1.子类拥有父类非private的属性，方法（private不可用于调用）
2.子类可以拥有自己的属性和方法，子类可以对父类的方法进行扩展
3.子类可以用自己的方法实现父类的方法（重写）
4.java的继承是单继承，一个类只能继承于一个类（不能继承多个类）
-- super关键字和this关键字
super是父类对象的一个引用
this是当前类对象的一个引用
-- 构造函数的调用
创建本类对象之前会调用父类的构造函数
例子
public class Husky extends Dog {
private int age=4;
public static void main(String[] args) {
Husky husky=new Husky();
husky.eat();
String type=husky.huoquleixing();
System.out.println(type);
int age=husky.age;
System.out.println(age);
}
public Husky(int age) {
super();//调用的父类构造函数
System.out.println("子类的构造函数");
this.age = age;
}
public Husky() {
}
@Override
public String huoquleixing() {
return "husky";
}}
-- 25/26封装
encapaulation，意思是将代码通过函数将一些代码细节包装起来，
防止外部代码的随机访问，要访问这些数据就必须通过调用函数来完成。
从而提高代码的阅读性和可维护性，同时也提高了数据的安全性。
public class Student {
private String age;//私有修饰属性值，不能被其他类调用，下面做成封装
public void setAge(int age){//封装成函数，可供调用
this.age=age+"";//当属性修改了时，改变函数，被调用的地方不用修改
}
}
-- 多态
多态，用父类的类型来接收子类的对象
先决条件：
1.继承
2.父类类型接收子类对象
优点：
扩展性强，解决了代码复用，降低类型耦合度
-- 多态下调用的注意事项
Parent aa=new Child();
aa.play();
aa.fish();
因为aa实际上是一个child对象，所以调用play函数的时候是先看子类有没有。
如果有，则调用子类函数；如果没有则调用父类的函数。
Parent aa=new Child();子类的对象可以用父类类型接收，这叫类型的向上提升
Child bb=(Child)aa;aa.play();
父类对象不能用子类类型来接收，除非父类的本质是一个子类对象（类型强制转换）
例子
public class Child extends Parent {
public static void main(String[] args) {
Parent child=new Child();//子类类型提升
child.fish();//多态，可以调用父类函数
child.play();//多态，可以调用父类函数
Child child2 =(Child)child;//类型强制转换为子类，才能调用子类的函数
child2.study();//调用子类的函数
child.study();//调用父类，但是如果子类有，父类会被子类重写，所有最后结果是调用子类
}
public void study(){
System.out.println("学习");
}
}
-- 修饰符主要分为两类
非访问修饰符和访问修饰符
-- 访问修饰符
权限
public，公共的，本类，同一个包下，非同一个包（子类），非同一个包（非子类）
protected，受保护的，本类，同一个包下，非同一个包（子类）
默认修饰符，默认的，本类，同一个包下，
private，私有的，本类
80
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
