初始JAVA
Write Once ， Run Anywhere
Java的三大版本
- JavaSE 标准版（桌面程序，控制台开发）
- JavaME 嵌入式开发（手机，小家电） (差不多死了)
- JavaEE E企业级开发（web端，服务器开发）
从JavaSE->JavaEE
从普通的程序代码进阶学习，打好基础。
win10截图快捷键
shift + win + s
JDK JRE JVM
JDK: java development kit （java开发者工具）
JRE：java runtime environment (java运行环境)
JVM：java virtual machine (java 虚拟机是跨平台的核心)
第一个HelloWorld
快速打开cmd方法（不用cd cd cd）
在文件绝对路劲前加cmd+空格
在cmd中如何运行
javac 代表编译+文件的名称后缀
之后 java hello 就可以运行了。 后缀.class可以省略
注意文件名和类名一致！
java程序运行机制
编译型（compile）：将程序全部转换为低级语言，再运行类似于笔译，翻译完整本书。
解释型：一边翻译一遍执行，类似于口译。
当我们执行javac的时候，相当于经过Java编译器 。
java注释
IDEA中修改comments的颜色
FILE->setting->Java->comments->line commnets and block comments
单行： // 快捷键：ctrl+/
多行：/* ----- */ 快捷键： shift + ctrl+ /
javadoc:文档注释
/**
*@Description HelloWorld
*@Author hujesse4
*/
java 标识符
关键字
所有的标识符都应该以字母（a-z或A-Z）或者$,或者_开头
像7DDh 就是不合法的
大小写敏感
数据类型
分为二类：基本类型(primitive type)和引用类型(.reference type)
不要使用浮点数进行比较。
布尔值拓展：
boolean flag=true;
if(flag==true){}
if(flag){}
// LESS IS MORE 代码要精简易读
数据类型转换
强制转换：（类型）变量名 高--低
自动转换 低--高
int i =128;
byte b=(byte)i // 属于由高到低需要强转
// ==========
int i=128;
double b=i; // 低到高
由低到高的排序：
byte->short->char->int->long->float->double
小剧场:
JDK7的新特效，数字之间可以用下划线分割
int money=10_0000_0000 // 可以轻松看出10万
sout（“money”） 时也不会有什么变化
String 是一个类，引用类。型
变量作用域
类变量
实例变量
局部变量
public class Variable{
static int allClicks=0; // 类变量
String str="helloworld"; // 实例变量
public void method(){
int i=0; // 局部变量
}
}
jvav中的常量
使用final 修饰
static final doudle PI=3.14;
变量的命名规范
所有变量，方法，类名：见名知意。
类成员变量：首字母小写和驼峰原则：monthSalary
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线;MAX_GoodMan
类名：首字母大写和驼峰原则：Man
方法名：首字母小写和驼峰原则:run()
运算符
if (a instanceof b)
if (a!=b)
只要讲一下位运算符：
A=0011 1100
B=0000 1101
-------------------
A&B=0000 1100
A|B=0011 1101
A^B=0011 0001
~B=1111 0010
还有<< >>
2*8 如何计算？
2*2*2*2 相当于0000 0010 左移二位 -》0000 1000
<< 左移 *2
>> 右移 /2
字符串如何连接 ,左侧拼接
字符串连接符 + ，String
String c = ""+a+b;
a=10;b=20
c=1020;
but
c=a+b+""
c=20;
三元运算符 x ? y : z
String type = score<60?"不及格"："及格";
package机制
package = 文件file
一般用公司域名倒置。 com.***就是这么来的
用户交互Scanner
java.util.Scanner 是java5的新特性 可以通过Scanner类来获取用户的输入。
Scanner s = new Scanner(System.in);
通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取之前我们一般需要使用hasNext()与hasNextLine()判断是否有输入的数据;
当我们键盘输入hello world
sout<<s.next();
hello.
说明next()截取空格之前的字符串。
而s.nextLine()截取enter键之前的
public static void main(String[] args) {
// 从键盘接受数据
Scanner scanner=new Scanner(System.in);
// 判断是否有输入
if(scanner.hasNextLine()){
String str=scanner.nextLine();
System.out.println("输出的内容位"+str);
}
scanner.close();
流程控制
顺序结构
选择结构
if单选则结构
if双选择结构
if多选择结构
嵌套的if结构
switch多选择结构
字符的本质还是数字
JDK7的新特性，表达式结果可以说字符串
String name=湖
switch(name){
case"湖":
cout("123")；break;
case"卡了"
cout(12323)；break;
}
IDEA实现反编译
1.打开File->Project Structure 找到project conpiler output
去文件夹找到.class 文件 . 复制
2.在IDEA里!
把复制的.class文件v到包里面下面是结果
反编译之后呢，发现他的代码与我们自己写的不是百分百吻合
循环结构
while 循环
do...while 循环
for 循环
print是不换行 println要换行
for循环是最有效，最灵活的循环结构
在IDEA中，可以使用100.for快速生成for循环
100.for = for(int i=0;i<100;i++){}
打印99乘法表
/*
1*1=1
1*2=2 2*2=4
---------------
1*9=9 -----------------9*9=81
============================
for (int i=1;i<10;i++){
for (int j=1;j<=i;j++)
System.out.print(j+"*"+i+"="+i*j+" ");
System.out.println();
}
增强for循环
主要用于数组或集合的增强for循环
for (Type x : array)
int [] array={10,20,30,40,15};
for (int x:array){
sout(x) //
}
Break Continue
break 用于强行退出循环，不执行循环中剩余的语句
continue 用于跳出循环体尚未执行的语句
while(i<100)
if (i%10==0){
sout(i);
continue
}
此时10的倍数就不会输出，程序也不会终止
打印三角形
for (int i = 1; i <= 5; i++) {
for (int j=5;j>=i;j--)
System.out.print(" ");
for (int j=1;j<=i;j++)
System.out.print("*");
for (int j=1;j<i;j++)
System.out.print("*");
System.out.println();
}
打印空串！
方法
何谓方法
拿System.out.println() 来分析，System是系统的一个类，out是一个System的输出对象，println（）是一个方法。
调用系统类里面的标准输出对象out中的println方法
方法就是函数的意思
方法的定义及调用
方法重载
命令行传参
package com.hujesse.Scanner;
public class forDemo04 {
public static void main(String[] args) {
for (int i = 0; i < args.length; i++) {
System.out.println(args[i]);
}
}
}
通过命令行的方式进入demo04 javac进行编译
然后返回src目录。因为包的关系
可变参数
最重要的递归
递归就是：A方法调用A方法！自己调用自己
public static int f(int n){
if(n==1) return 1
else
return n*f(n-1);
}
能不用递归就不要用递归
数组
数组概述
数组是相同数据类型的有序集合
数组描述的是相同类型的若干个数据，按照一定的先后次序排序组合而成 每个数据称为一个数组元素，可以通过下标来访问
数组声明创建
dataType[] arrayRefVar; // 首选的方法
dataType arrayRefVar[]; // 相同的方法，但不是首选
java语言使用new操作符来创建数组，语法如下：
dataType[] arrayRefVar = new dataType[arraySize];
int [] nums = new int[10]
数组的元素是通过索引访问的，数组索引从0开始
获取数组长度： arrays.length
内存分析
对于八种基本数据类型,byte,short,int,long,float,double,char,boolean 这八种类型存储时是存储在内存中的 栈内存中,而引用数据类型,如类类型,数组类型,对象类型的值是存在内存中的堆内存中
数组本身就是对象，因为数组也是new出来的。java中的对象是在堆中的。
数组使用（初始化）
//静态初始化
int []a = {1,2,3,4,5};
// 动态初始化
int b[] = new int[10];
如果没赋值，隐式值为0
数组的遍历
1. foreach循环，idea中快捷键为数组名.fro
2.普通for循环
* 数组作方法传参
*数组作返回值
多维数组
定义：int a[][]=new int[2][5];
和c++相比真的简单太多了不用二次new，还要最终销毁
Arrays类
数组的工具类java.util.Arrays,API中提供了一个工具类Arrays供我们使用
查看JDK帮助文档
Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用
========================
具有一下常用功能
1.给数组赋值：通过fill方法
2.对数组排序：通过sort方法，按升速
3.比较数组，通过equals方法比较数组中元素值是否相等
4.查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找
稀疏数组
对象
什么是面向对象
本质：以类的方式组织代码，以对象的形式组织（封装）数据
先有对象后有类。对象是具体的事物，类是抽象的，对对象的抽象
三大特性：封装，继承，多态
this
public class Student{
String name;
int age;
public void study(){
sout(this.name+"在学习");
}
}
this 代表当前对象
类是抽象的，需要用new来实例化一个对象。、
修饰符的范围：
public > protected > Default > private
构造器
分为有参和无参，目的是为了初始化对象。快捷键alt+insert 可以快速生成构造方法。
1. 和类名相同
2.没有返回值
作用：new本质在调用构造方法。初始化对象的值
创建对象内存分析
注意：方法区也是堆的一部分。
封装（数据的隐藏）
1.设计程序要“高内聚，低耦合”，高内聚就是类的内部数据操作自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用
2.（封装）数据的隐藏
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问。即私有属性，get/set
set 方法也可以进行值的校验
public void setAge(int age){
if (age>120||age<0)
this.age=0; // 当年龄不合法
else
this.age=age // 合法
}
继承(extends)
JAVA类中只要单继承，没有多继承。
继承是类和类之间的一种关系。初次之外，类和类之间的关系还有依赖，组合，聚合等
子类（派生类）继承父类 is a 的关系
1.Object类
ctrl + h 可以打开一个继承树
java所有的类，都默认直接或间接继承Object
such as
public class person /* extends Object */
{
}
2.super
spuer 注意点
1. super调用父类的构造方法，必须在构造方法的第一个
2.spuer必须只能出现在子类的构造方法中。
3.super和this不能同时调用构造方法
不同：
this=本身调用者
super=父类对象
构造方法：
this(); 本类的构造；
super(); 父类的构造；
3.方法重写==》 多态
给出父类B，子类A
public class B{
public static void test(){
Sout("B=>test");
}
}
public class A extends B{
public static void test(){
Sout("A=>test");
}
}
Application.java
psvm{
A a = new A();
a.test(); // 输出为A=>test
B b = new A();
b.test(); // 输出为B=>test 但如果A,B二个类的方法没有static，则 输出为A=>test
}
父类的调用指向子类.
只有非静态方法才叫重写！！
只要子类继承了父类才有重写这一说法。
为什么需要重写： 父类的功能子类不一定需要，或者不一定满足
多态·
既同一方法可以根据发送对象的不同而采取不同的行为方式
1.父类引用指向子类的对象
2.把子类转换为父类，向上转型
3.把父类转换为子类，向下转型4，强制转换
static关键字
代码块执行次序
public class demo{
{
sout("默认代码块")
}
static{
sout("静态代码块")
}
public person(){
sout("构造方法")
}
psvm{
Person pers = new person();
}
}
输出的是静态-》默认=》构造代码块
static只执行一次，随类一起加载，static的东西加载到堆里面的静态资源区
static nb的地方
抽象（abstract）类
使用：在类和方法前加abstract修饰符
如果子类继承了一个抽象类，那么子类必须实现父类所有的抽象方法。
类是单继承，但接口可以多继承
1. 不能new一个abstract类，只能靠子类去实现；约束！
2.抽象类可以写普通的方法。
3.抽象方法必须在抽象类中。
接口
普通类：只要具体实现
抽象类：具体实现和规范（抽象方法）都有
接口：只要规范！
定义接口的时候，如
public interface UserService{
public abstract void run();
}
// 其实public 和abstract都是被省略了的
多继承：
public class UserService implements UserService,TimeService
可以继承多个
接口与抽象类的区别：
1. 接口使用interface 和 implements 可以多继承
2.抽象类使用 abstract 和 extends 只能单继承
内部类
public class Outer{
private int id;
public void out(){
sout("这是外部类");
public class Inner{
public void in(){
sout("这是内部类");
}
}
}
}
psvm{
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.in();
}
很抽象的实例化内部类。
一个java文件中，可以有多个class类，只能有一个public。
Error and Expection
什么是异常
异常：Exception ,程序运行过程中，非常可能遇到刚刚提到的这些异常问题。
Error与Exception的区别：Error通常是灾难性的致命错误，是程序无法控制和处理的，当出现这些异常时，JVM一般会选择终止线程；Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常。
异常体系结构
java异常处理机制
抛出异常
捕获异常
异常处理五个关键字：
try,catch,finally,throw,throws
选中代码之后，alt+ctrl+T可以操作
int a =1;
int b = 0;
try { // try代码块是一个监控区域
System.out.println(a/b);
}catch (Exception e){ // 捕获异常
System.out.println("程序出现异常变量不能为0");
}finally {
System.out.println("finally");
} // finally可以不要，但一般用来处理I/0，资源的关闭。
主动抛出异常 // 一般在方法中使用
public void test(int a,int b){
if (b==0)
throw new Exception(); // 主动的抛出异常
}
}
throws在方法上使用：
public void test throws Exception{};
自定义异常
总结
英文单词笔记
IDE: Integrated Development Environment 集成开发环境
粗体：blod 斜体：italic
注释：comment
line comment 单行注释， block comment ，多行注释
constant：常量。 initialize：初始化。
java.lang.ArrayIndexOutOfBoundsException:1 : 这个错误是指数组下标越界。
object-oriented programming oop 面向对象编程