变量：可变的量
语法：数据类型 变量名；
定义
赋值，初始化
变量使用前一定要先赋值
变量值和类型要对应
一个变量只能创建一次
变量的值可以改变
String:字符串
int:整数数字
作用域：适用范围 变量所在的{}内赋值
标识符：自己定义的一些名称
命名规则：由字母、￥、_、数字、汉字组成，数字不能开头，不能使用关键字，goto也是关键字
命名规范：不用汉字，见名知意
变量，方法：首字母小写
类名：首字母大写
常量：全用大写字母
泛型：单个大写字母
驼峰命名法：第一个单词后面每个单词首字母大写 goToSchool
数据类型：
基本数据类型：变量中存放的是数据 1 2 4 8 16 32 64 128
整形：
byte:1字节8位 -123~127
short：2字节16位 -2^15~2^15-1
int:4字节32位 -2^31~2^31-1
long:8字节64位 -2^63~2^63-1
浮点型：
float:4字节32位
double:8字节64位
字符：
单引号表示字符，双引号表示字符串
char 点阵图 图形和数字对应关系就是字符集编码 Java默认使用的是unicode
布尔型：
boolean:true false
字面量：类型
""字符串
''字符
整数为int类型
小数为double类型
true和false为布尔类型
数据类型转化
小转大，可以转，大转小，要强转（可能会损失精度）
数据前面假（转化后的数据类型）
整形的字面量只要在范围之内，可以转化为 byte short char 类型
引用数据类型：变量中存放的是数据所在的引用
表达式：由变量，字面量，运算符组成的有结果的式子
类型：参与运算中类型最大的类型
字符串+任意类型结果都是字符串
运算符：
四则运算符： + - * / % 4.5 % 1.2 3.3 2.1 0.9
简写
+= -= *= /= %= ++ --
关系运算符： < > >= <= == !=
运算结果为boolean(4>5>6)
字符串比较不用== 用equals方法
逻辑运算符：专门用于boolean运算 && || ！ 与 或 非 and or not
短路运算符 && 只要有一个为false 后面的就不在参与运算
|| 只要有一个为true 后面的就不再参与运算
位运算符： | & ^
三元运算符(三目运算符)： 表达式a?表达式c
a只能是boolean类型
b和c是相同类型
a为true 值为b
a为false值为c
从控制台获取数据
Scanner s = new Scanner(System.in);
int i = s.nextInt();
double d = s.nextDouble();
String str = s.nextDouble();
改变程序的运行顺序
分支语句
if分支
语法：a、if（表达式）{代码} 表达式为true执行代码，为false不执行代码
b、if（表达式a）{代码1}else{代码2} 表达式为boolean类型 表达式为true执行代码1 表达式为false执行代码2
c、if(a1){b1}else if(a2){b2}else if(a3){b3}…else if(an){bn}else(bn+1)
无论任何情况都只会执行一个代码块
switch分支 c的取值可以是可以转化为int类型的数据，字符串，枚举
语法：a、switch©{
case a;
b;
break;
case a1;
b1;
break;
default:
bn;
break;
}
循环语句:循环条件 循环体
while：while(表达式a){代码b}
do while:do{代码b}while(表达式a);
会先执行一次代码b再去看循环条件a。
break:终止语句的运行
continue:停止当次循环，直接进入循环条件的判断
return:结束方法运行
for example:
int day = 0;
do{
day++;
System.out.println("第"+day+"天跑步完成");
}while(day>10);
（）{}这种结构，如果{}中只有一句代码，{}可以省略
数组：
例：new int[5] 长度为5数组的数据
数组里面的数据为元素，每个元素都有一个编号叫下角标，编号从0开始
赋值；通过下角标赋值，取值也用下角标
若创建时没有辅值，所有元素都会有一个默认值，为对应数组类型的默认值（int为0，double为0.0，。。）
,引用数据类型为null
数组下角标的范围为0~（长度-1） ，超过范围会报错
取用数组的元素用循环
int[] scores = new int[5];
scores[0] = 21;
....
int i = 0;
while(i<scores.length){
System.out.println(scores[i]);
i++;
}
增强型循环：foreach,遍历,一般不能改变里面的数据
foreach(类型+ 变量名：数组或集合){}
foreach(int j: scores){
System.out.println(j);
}
随机数：Random r = new Random();
数组创建时可以赋值(不用指定长度)：
int[] a = new int[]{3,5,7,8,9,7}
int arr[] = {2,5,5,8,9,4};
for(int x: arr ){
System.out.println(x);
}
选择排序算法:
二维数组：数组的元素是数组
int[][] arr = new int[该数组长度][];
int[][] arr = new int[5][];
数组的动态初始化：数据类型 对象数组[][] = new 数据类型[行个数][列个数];
数组的静态初始化：数据类型 对象数组[][] = new 数据类型[行个数][列个数]{{值, 值,…}, {值, 值,…},…};
JAVA中定义数组的三种类型：
int[] arr1=new int[10];
int[] arr2={1,2,3,6};
int[] arr3=new int[]{1,2,3,4,5,6,7,22};
定义数组只有两种方式
1.int[] a
2.int a[]
注意：数组的length是一个属性，而字符串的length()是一个方法了！！！虽然都是求的他们各自的长度
换位置
int tmp = a[i][j];
===========================================================================
方法（位置：类里面，其他方法外）：
定义：修饰符（适用范围）
返回值类型 （没有返回值类型的话 方法建立时就用void）
return:结束方法的运行//返回值类型
方法名
参数表：使用方法时需要给到方法的数据
形参：没有确切的值。和定义变量一样，多个用逗号隔开，没有可以不写，但()不能少
example:
//**计算两个和的方法
* 有参有返回值
*/
public static int add(int a, int b){
int sum = a + b;
return sum;
}
//**遍历一个数组的方法
* 有参无返回值
*/
int[] a =new int[] {1,2,3};
list(a);
public static void list(int a[]){
if( a == null){
return;
}
for(int i: a){
syso(i);
}
}
//**无参有返回值
*/
调用：syso(AKA());
public static long AKA(){
return 2288278879l;
}
方法的调用：通过 -方法名（参数）调用。
❤：此时参数要给具体的值（实参-有实际的值）
形参-实参 ：一一对应（类型，数量，位置）
如果在同一类型中，方法名相同，参数表不同，这一系列方法称重载方法；
可变参：在方法中，会将传入的参数当作已数组来使用
int…a 只能放在参数表的最后，同一个方法只能有一个可变参
example:
调用： sum(1,2,3,4,15);
public static void int sum(int... a){
int sum = 0;
for(int i: a){
sum += i;
}
return sum;
}
递归：在方法中调用当前方法
计算1+2+3+。。。。+n的和:
1.0
syso(f(200));
public static void int f(int n){
if( n == 1){
return 1;
}
return f(n-1)+n;
}
2.0
syso(fun(3000000));
public static void long fun(long n){
long sum = 0;
for(long i = 0;i <= n; i++){
sum += i;
}
return sum;
}
(值传递/引用传递了解)
oop:面向对象编程
o:对象
抽象对象：将对象用计算机语言描述
特征：可以确认到具体的某一个对象
行为：此对象有什么作用（会做什么事）
类型（也具有特征和行为）：先有类型再有分类--对象的抽象
如果没有给属性赋值，系统会给默认值
内存：
栈区：变量，基本数据类型
堆区：对象，引用数据类型
方法区：方法，类型
运行过程(先看有没有这个方法)：
1.先在方法区加载类型，加载类型中所有有实现的方法
2.堆区-给属性赋值（没有赋值为默认值）---栈区变量指向堆区的属性
-建立方法的指针
3.堆区调用方法区的方法：
-先看变量的类型中有没有这个方法的实现
-再去看对象指向方法的修饰符是否可以被调用
this关键字：当前属性
全局变量：类的属性
局部变量：方法中的变量
要使用全局变量：加this---(this.name)
包（package）：类型的一个分类
命名：公司||项目域名反写 www.baidu.com–>com.baidu.www
========================================================================================
构造方法：
一、特殊的方法：
1.没有返回值类型
2.方法名和类名一致
3.调用只能通过new来调用
4.如果一个类型中没有写构造方法，在编译时会默认编译一个无参数的构造方法，如果有就不会自动添加
5.可以在构造方法里通过 this(); (只能写在第一行) 调用构造方法
二、作用：创建对象，创建对象时被调用，一般用于给对象初始化
每次new都在堆区创建一个对象，用this()就不会，且只能写在第一行
面向对象三大特点：
1.封装：创建对象的过程，创建类型时对属性私有化-private-，如果有操作都通过方法
JavaBean（写类型的一种标准）:有无参构造方法，所有属性私有化，对所有属性向外提供对应的setter和getter方法
2.继承：
3.多态：
继承：
1. 体现一种类型与类型间的关系，一个类型继承另一个类型，父类子类
2. 父类中的属性和方法在子类中也会被继承过来，用关键字extends来描述，子类extends父类
3.私有属性和方法不能被继承（private）
4.构造方法不能被继承
5.Object是所有类型的父类
-----------------------------------------------------------------------------
0重写： 在java程序中，类的继承关系可以产生一个子类，子类继承父类，它具备了
父类所有的特征，继承了父类所有的方法和变量（方法名称，参数类型，返回值类型全部相同）
当父类的方法满足不了子类，可在子类中再写一个和父类相同的方法
修饰符：要比父类的更大
异常：必须是父类异常或者其子类
返回值：和父类一样或者父类返回值的子类
有static 、final 、private、 构造方法等不能重写
0重载： 方法重载是让类以统一的方式处理不同类型数据的一种手段。
例子：
方法1
主函数{
创建新对象
新对象.方法1（设值1）；
新对象.方法1（设值2）；
新对象.方法1（设值3）；
}
----------------------------------------------------------------------------
抽象方法：
只有定义没有实现的方法
必须用abstract修饰
必须写在抽象类型或接口中
抽象类型：
用abstract修饰的类型，不能有实例化对象，只能通过子类来调用方法
子类必须重写所有的抽象方法
----------------------------------------------------------------------------
0接口： 用interface来定义的，接口中只能有抽象方法-修饰符只能是（public abstract），变量只能是静态常量-修饰符只能是（public static final）
interface的默认修饰符是public static void +。。。
接口的子类类型叫实现，子类必须重写父类中的所有的抽象方法
接口都可以继承接口，可以多继承
(int)(Math.random()2)==0?“男”:“女”
公式：(数据类型)(最小值+Math.random()(最大值-最小值+1))
2020.10.26
修饰符：
作用：
权限修饰符（修饰使用权限）：
public:所有类中都可使用（不同包下也可），使用范围最广
protected:当前所在包下面才可使用，或者子类中也可使用
default(空白/没有修饰符，习惯命名为default(比如：int a)):只能在当前包下使用
private:只在当前类下使用
static(静态的):
属性：类加载时就加载，属于类型的（在方法区里的一个空间-静态区/公共区）-所有属性使用同一个对象（变量），可以直接通过类型调用（不需要对象）
方法：类加载时就加载，属于类型的，可以直接通过类型调用（不需要对象）
----非静态属性/方法一定需要对象才能调用----
----非静态可以调用静态，静态不能调用非静态----
类型：只能修饰内部类，和普通类型没有区别
final(最终的):
属性：值不能改变（只能赋值一次），属性名一般全用大写字母
方法：不能重写
类型：不能被继承
2020-10-27
多态：父类的引用指向子类的实例（父类的变量指向子类的方法）
正则表达式（百度）
2020.10.28
date:
时间戳
块：一个大括号（{}）就是一个代码块
特殊块：构造块（写在方法之外，类体中的代码块）
0运行顺序：先调用执行构造块，再调用执行构造方法
静态块：用static修饰的块，类加载时执行（最先执行，不管位置在哪（如果在父类，子类中都有--先执行父类和子类的静态块，再执行构造块，再执行构造方法，再执行普通方法）），
只会执行一次
static{
System.out.println("这是一个静态块");
}
(了解)内部类：
public class A{
class B{
int a;
...
}
}
2020-10-29
泛型：（单个大写字母命名）----了解
example: public class Haspital<A\B\C\D\E…>{}
如果泛型的类型没有指定，默认为Object
封装类型：
所有的数据类型基本都有一个引用数据类型(如下)：
byte Byte
short Short
int Integer
long Long
char Character
float Float
double Double
boolean Boolean
public static void main(){
int i = 10;
Integer ab = new Integer();
i=ab;
}
集合：
集合架构图(百度) 要记重点 如:Hashmap…
List:可以改变大小的数组（使用JDK查询具体使用语法）
List<Integer> list = new ArrayList<>();
//添加元素
list.add(10);
list.add(100);
list.add(230);
//获取
list.get(1);
//排序
list.sort(null);
//为null的话 可以对纯数字和String类型进行排序
//
//删除
list.remove(1);
list.remove(new Integer(230));
Syso(list);
//遍历
for(int i = 0;i < list.size(); i++){
syso(list.get(i));
}
for(Integer i: list){
syso(i);
}
//迭代器遍历 所有list和set集合都有一个迭代器
Iterator<Integer> it = list.iterator();
while(it.hasNext()){
int i = it.next();
syso(i);
}
//删除集合里的偶数
Iterator<Integer> it = list.iterator();
while(it.hasNext()){
Integer i = it.next();
if(i&2==0){
it.remove();
}
}syso(i);
4466
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
