学习，要阅读别人的源码
java入门
算法是计算机的灵魂，编程语言是塑造计算机灵魂的工具，核心是算法
java广泛应用于企业级软件开发，安卓移动开发，大数据云计算等领域，几乎涉及IT所有行业
java 发展简史
java核心优势----->跨平台/可移植性，例如Java的int永远都是32位
第一大语言，安全性，跨平台，面向对象，简单性，高性能，分布式，多线程，健壮性
java三大版本
JavaSE(Java Standard Edition):标准版，定位在个人计算机上的应用
JavaEE(Java Enterprise Edition):企业版，定位在服务器端的应用
JavaMe(Java Micro Edition):微型版，定位在消费性电子产品的应用上
计算机高级语言的类型主要有编译型和解释型，而java语言是两种类型的结合。
Java首先利用文本编辑器编写Java源程序，源文件的后缀名为.java，
再利用编译器(javac)将程序编译成字节码文件，字节码文件的后缀名为.class，
最后用虚拟机(解释器，java)解释执行
JVM(Java Virtual Machine)就是一个虚拟的用于执行bytecode字节码的'虚拟计算机'。
JRE(Java Runtime Environment)包含：Java虚拟机，库函数，运行Java应用程序所必须的文件。
JDK(Java Development Kit)包含：包含JRE，以及增加编译器和调试器等用于程序开发的文件。
JDK的安装，环境变量的配置，测试JDK是否安装成功命令行执行：java -version
错误就是提高的机会！解决的错误越多，提高得越快，能力越强
Java对大小写敏感，public是访问修饰符，class是类
一个源文件可以包含多个类，但一个源文件中至多只能声明一个public类
以分号结束
标识符的使用规范
表示类名的标识符
每个单词的首字母大写，如Man, GoodMan
表示方法和变量的标识符
第一个单词小写，从第二个单词开始首字母大写，我们称之为“驼峰原则”，如eat(), eatFood()
java是强类型语言，每个变量都必须声明其数据类型
局部变量：
方法或语句块内部定义的变量，定义变量后必须初始化才能使用
成员变量，也叫实例变量 member variable
方法外部、类的内部定义的变量，从属于对象，生命周期伴随对象始终。
如果不自行初始化，它会自动初始化成该类型的默认初始值。
int-->0;double-->0.0,char-->'\u0000',boolean-->false
静态变量，类变量static variable
使用static定义，从属于类，生命周期伴随类始终，从类加载到卸载
常量(Constant)，大写
利用关键字final来定义一个常量，常量一旦初始化后不能改变其值
java中float比较不精确，浮点类型默认是double
char是字符，String是字符串
boolean类型有两个常量值，true和false，在内存中占一位，不是一个字节
取模运算，余数符号和左边操作数相同
单引号是char，双引号是string
方法的调用方式
形参，实参，返回值（事先约定返回值的数据类型，如无返回值，必须显示指定为void）
return 两个作用：1.结束方法的运行 2.返回值
传递参数，遵循值传递的原则(传递的都是数据的副本)
java 中存在重载
方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法。
调用时，会根据不同的参数自动匹配对应的方法。
重载的方法，实际是完全不同的方法，只是名称相同而已!
构成方法重载的条件：
1.不同的含义：形参类型、形参个数、形参顺序不同
2.只有返回值不同不构成方法的重载
面向过程和面向对象
面向对象具有三大特征：封装性、继承性和多态性，
相辅相成的关系
面向过程和面向对象都是对软件分析、设计和开发的一种思想，它指导着人们以
不同的方式去分析、设计和开发软件
类可以看做是一个模版，或者图纸，系统根据类的定义来造出对象。
static修饰的方法，可以直接调用
package pro01;
public class BallGame{
public static void main(String[] args) {
int a =30;
int b = 50;
int c = Test(a,b); -- 直接调用
System.out.printf("结果是 %d+%d=%d",a,b,c);
}
static int Test(int a,int b) { -- static 可以直接调用，不必实例化对象
System.out.println("aaa");
return a+b;
}
}
属性fields或者称为成员变量，在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。
基本的类
package pro01;
public class Student {
-- 属性fields
int id;
String name;
int age;
-- 方法
void study() {
System.out.println("study!!!");
}
void play() {
System.out.println("play!!!");
}
-- 程序执行的入口，必须要有
public static void main(String[] args) {
Student s = new Student(); -- 实例化类，生成对象
s.play();
}
* 构造方法，用于创建这个类的对象，如果没有自行提供构造方法，则系统会自动创建无参的构造方法。
* Student(){
* }
}
调用外部的类
package pro01;
public class Student {
//属性fields
int id;
String name;
int age;
Computer comp;
//方法
void study() {
System.out.println("study!!!");
}
void play() {
System.out.println("play!!!"+comp.brand);
}
//程序执行的入口，必须要有
public static void main(String[] args) {
Student s = new Student(); //实例化类，生成对象
s.name = "张三";
Computer comp1 = new Computer();
comp1.brand = "华硕";
s.comp = comp1;
s.play();
}
}
class Computer{
String brand;
}
打印：
play!!!华硕
Java虚拟机的内存可以分为三个区域：栈stack、堆heap、方法区method area
栈的特点如下：
1.栈描述的是方法执行的内存模型，每个方法被调用都会创建一个栈帧(存储局部变量、操作数、方法出口等)
2.JVM为每个线程创建一个栈，用于存放该线程执行方法的信息(实际参数、局部变量等)
3.栈属于线程私有，不能实现线程间的共享！
4.栈的存储特性是"先进后出，后进先出"
5.栈是由系统自动分配，速度快！栈是一个连续的内存空间！
堆的特点如下：
1.堆用于存储创建好的对象和数组(数组也是对象)
2.JVM只有一个堆，被所有的线程共享
3.堆是一个不连续的内存空间，分配灵活，速度慢！
方法区(又叫静态区)特点如下：
1.JVM只有一个方法区，与所有线程共享！
2.方法区实际也是堆，只是用于存储类、常量相关的信息！
3.用来存放程序中永远是不变或唯一的内容。(类信息[Calss对象]、静态变量、字符串常量等)
Java中""中存放的是字符串常量
构造器也叫构造方法(constructor),用于对象的初始化。
1. 通过new关键字调用!!
2. 构造器虽然有返回值，但是不能定义返回值类型(返回值的类型肯定是本类)，不能在构造器里使用return返回某个值。
3. 如果我们没有定义构造器，则编译器会自动定义一个无参的构造函数。如果已定义则编译器不会自动添加!
4. 构造器的方法名必须和类名一致!
Java中引入了垃圾回收机制，垃圾回收过程
1. 发现无用的对象
2. 回收无用对象占用的内存空间。
分代垃圾回收机制
this 指代当前对象
this最常的用法：
1. 在程序中产生二义性之处，应使用this来指明当前对象;
普通方法中，this总是指向调用该方法的对象。构造方法中，this总是指向正要初始化的对象。
2. 使用this关键字调用重载的构造方法，避免相同的初始化代码。但只能在构造方法中用，并且必须
位于构造方法的第一句。
3. this不能用于static方法中，（static中没有this）
对象创建的过程和this的本质
在类中，用static声明的成员变量为静态成员变量，也称为类变量。
类变量的生命周期和类相同，在整个应用程序执行期间都有效。它有如下特点：
1. 为该类的公用变量，属于类，被该类的所有实例共享，在类被载入时被显式初始化。
2. 对于该类的所有对象来说，static成员变量只有一份。被该类的所有对象共享!
3. 一般用“类名.类属性/方法”来调用，也可以通过对象引用或类名(不需要实例化)访问静态成员。
4. 在static方法中不可直接访问非static的成员，static修饰的成员变量和方法，从属于类。
普通变量和方法从属于对象的。
Java中，方法中所有参数都是“值传递”，也就是“传递的是值的副本”。而引用类型指的是“对象的地址”。
java中的包
1. Java会默认导入java.lang包下所有的类，因此这些类我们可以直接使用
2. 如果导入两个同名的类，只能用包名+类名来显式调用相关类
静态导入
import static java.lang.Math.*;
import static java.lang.Math.PI;
方法的重写override
子类通过重写父类的方法，可以用自身的行为替换父类的行为
== 与 equals
“==”代表比较双方是否相同。如果是基本类型则表示值相等，如果是引用类型则表示地址相等，即是同一个对象。
Object 的 equals 方法默认就是比较两个对象的hashcode，是同一个对象的引用时返回 true，否则返回 false。
但是，我们可以根据我们自己的要求重写equals方法。
属性/方法查找顺序：(比如：查找变量h)
1. 查找当前类中有没有属性h
2. 依次上溯每个父类，查看每个父类中是否有h，直到Object
3. 如果没找到，则出现编译错误。
4. 上面步骤，只要找到h变量，则这个过程终止。
构造方法调用顺序：
构造方法默认第一句总是：super(…)来调用父类对应的构造方法。所以，流程就是：
先向上追溯到Object，然后再依次向下执行类的初始化块和构造方法，直到当前子类为止
注：静态初始化块调用顺序，与构造方法调用顺序一样，不再重复
封装:提高代码的安全性，提高代码的复用性，高内聚，低耦合
各种属性: public, protecte, default, private
用private设置私有属性，只能在类中访问
package pro01;
class Test{
private String name;
private int age;
private boolean flag;
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
if(age>0 && age<120) {
this.age = age;
}else {
System.out.println("this age [" + age + "] not is a valid age!!");
}
}
public int getAge() {
return age;
}
}
public class Home{
public static void main(String[] args) {
Test t = new Test();
t.setName("libai");
System.out.println(t.getName());
t.setAge(130);
System.out.println(t.getAge());
t.setAge(55);
System.out.println(t.getAge());
}
}
java的多态(polymorphism)
多态指的是同一个方法调用，由于对象不同可能会有不同的行为。
继承，方法重写，父类引用指向子类对象。
package pro01;
class Animal{
public void Shout() {
System.out.println("call something");
}
}
class Dog extends Animal{
public void Shout() {
System.out.println("dog call");
}
}
class Cat extends Animal{
public void Shout() {
System.out.println("cat call");
}
}
public class Home{
public static void main(String[] args) {
Animal a = new Animal();
CallShout(a);
CallShout(new Dog());
}
static void CallShout(Animal animal) { -- 这里就体现了多态的作用
animal.Shout(); -- 只需要用一个Animal就可以代替Dog和Cat类的对象
}
}
对象的转型(casting)
final关键字的作用
1. 修饰变量: 被他修饰的变量不可改变。一旦赋了初值，就不能被重新赋值。
2. 修饰方法：该方法不可被子类重写。但是可以被重载!
3. 修饰类: 修饰的类不能被继承。比如：Math、String等。
Java中的数组
数组就是对象（存储在堆中）
数组是相同类型数据的有序集合，注意是相同类型，与python不同
1. 长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
2. 其元素必须是相同类型，不允许出现混合类型。
3. 数组类型可以是任何数据类型，包括基本类型和引用类型。
声明一个数组的时候并没有真正创建，只有实例化数组对象时，JVM才分配空间。
创建方式
type[] arr_name; //（推荐使用这种方式）
遍历数组，for，for-each
package pro01;
public class Home{
public static void main(String[] args) {
int[] arr = null;
arr = new int[4];
-- 初始化元素的值
for(int i=0;i<4;i++) {
arr[i] = 10*i;
}
-- 读取元素的值
for(int i=0;i<4;i++) {
System.out.println(arr[i]);
}
-- for-each循环用于读取数组元素的值，不能修改元素的值
for(int m:arr){
System.out.println(m);
}
}
}
抽象类
通过抽象类，可以避免子类设计的随意性。
1. 有抽象方法的类只能定义成抽象类
2. 抽象类不能实例化，即不能用new来实例化抽象类。
3. 抽象类可以包含属性、方法、构造方法。但是构造方法不能用来new实例，只能用来被子类调用。
4. 抽象类只能用来被继承。
5. 抽象方法必须被子类实现。
package com.ss;
public abstract class Animal {
public abstract void run(); -- 子类必须重写父类的run方法
}
class Dog extends Animal {
@Override
public void run() {
System.out.println("must to override run");
}
}
接口interface，接口支持多继承
package com.ss;
public interface Animal {
-- 接口中只有：常量，抽象方法
-- public static final 接口中常量定义时，写或不写都是这样
String name = null;
-- public abstract 定义方法中也是默认这两个类型
public void testA();
public void testB();
}
class Dog implements Animal{
public void testA() {}
public void testB() {}
}