学习记录----科研之余-准备工作-

学习目标：

掌握 Java 基本知识，理解基本概念。

---

学习内容：

B站尚硅谷Java入门视频

---

一、基础概念

1、JavaSE、JavaEE

Java标准版与企业版，javaSE和javaEE的基础知识一样，大部分都以javaSE当作学java基础了。后面再去学JavaEE的知识，框架。

2、JVM

Java Virtual Machine， Java虚拟机。java语言的特点是可以多平台使用，只需要平台（操作系统）安装JVM即可。

3、JDK、JRE

Java development kit, java开发工具包
Java runtime environment, Java运行环境
JDK里包含了JRE，所以安装一个jdk就行了。

4、JDK、JRE、JVM关系

JDK = JRE + java开发工具
JRE = JVM + javaSE标准类库（API）

5、API

Application Programming Interface，应用程序编程接口。Java提供的一些类库/接口，把它称为Java API。

6、JavaBean

JavaBean 是符合以下标准的java类
（1）类是公共的；
（2）有一个无参的公共的构造器；
（3）有属性，且有对应的set/get方法。

7、UML类图

UML Class Diagram。
能看懂就行。

8、MVC设计模式

MVC是一种设计模式，将程序 输入输出、数据处理、数据展示分离开的设计模式。
（1）Model：模型层，主要处理数据。
（2）View：视图层，显示数据。
（3）Controller：控制层，主要处理业务逻辑。

9、单例设计模式

在设计过程中，保证整个系统中，某个类 只能存在唯一一个实例对象。

饿汉式 vs. 懒汉式

10、代码块

a. 静态代码块：随着类的加载而执行。每次使用类.xx都会执行。只执行一次。
	static {
		...
	}
b. 代码块：随着对象的加载而执行。每次new对象时都会执行。
	{
		...
	}

11、模板方法设计模式 TemplateMethod

抽象类：父类设计的很抽象，没有具体的实例。

抽象类作为多个子类的通用模板，子类在抽象类的基础上扩展、改造，但子类总体上会保留抽象类的行为方式。

理解：就比如设计一个算法时，整体步骤在父类中写完了，但是有一部分是易变的，
	 那么就把易变的一部分抽象出来交给子类来实现（比如重写抽象方法）。

![1

二、基础知识

1、数据类型间的运算

（1）小容量的与大容量的运算，自动提升为大的。
byte, char, short --> int --> long --> float --> double
（2）String 与它们计算结果 表示连接。就是前后连起来。

2、算术运算符：自增自减

（1）++a：先自增，再运算；
（2）a++：先运算，再自增。
（3）-- 同理。

3、逻辑运算符：&与&&

（1）相同点：都是与（单与|逻辑与，双与|短路与），运算结果是一样的
（2）不同点：双与，如果左边为false，则不再执行右边的；单与，左边为false，也要执行右边。

4、位运算符：<<

（1）左移1位，等同于乘以 2； a << 1   =  a * 2。
（2）右移同理。
（3）最高效的计算 2*8 ？  2<<3 | 8 << 1.

5、

三、面向对象

1、面向过程与面向对象

相同点：都是编程的设计思想
不同点： 
	面向过程，强调实现什么功能行为？以函数为最小单位。怎么做？
	面向对象，强调具备某些功能的对象！以类与对象为最小单位。谁来做？

举例：把大象装进冰箱
面向过程的思想：设计3个函数，（1）开门（2）装大象（3）关门。
面向对象的思想：设计3个类，类中有方法，最后new对象出来，让对象干这事。
			   人{
			   		打开（冰箱）{
			   				冰箱.打开（）；
			   		}
			   		抬起（大象）{
			   				大象.抬起（）；
			   		}
			   		关闭（冰箱）{
			   				冰箱.关闭（）；
			   		}
			   }
			   冰箱{
			   			打开（）；
			   			关闭（）；
			   }
			   大象{
			   			进入（冰箱）；
			   }

面向对象的思想，逻辑结构更加清晰，以后代码完善/更新时更方便。

2、面向对象的两个要素

类与对象
（1）类：客观抽象出来的。比如：人。
（2）对象：实例，真实存在的。比如：小明。

3、JVM内存结构

Ref：一文搞懂JVM内存结构

编写的.java文件会被编译器编译为.class字节码文件，然后在JVM上解释运行。

解释运行时涉及到内存的解析。
	
	(1) 虚拟机栈，将局部变量存储在栈里。
	(2) 堆，将new出来的东西，加载在堆空间中。对象的属性（非static）也加载在堆空间中。
	(3) 方法区：类的加载信息、常量池、静态域。

4、方法的重载

（1）重载：在一个类中，方法名可以重复，参数个数/参数类型不同就行。

5、方法的重写

（1）重写：从父类中继承到的方法（同名同参数），覆盖。
（2）父类中private权限的方法不能被重写。只能重写非static的，static不能被重写。
	@Override

6、面向对象的三大特征

高内聚、低耦合：（高内聚：类内部的复杂设计不允许外界干预，低耦合：仅对外暴露简单的方法使用。）

封装、继承、多态。
（1）封装性的设计思想：该隐藏的隐藏，该暴露的暴露。隐藏对象内部的复杂性，只对外公开简单的接口。
	封装性的体现：
	a. 用权限修饰符：private / default / protected / public
	b. 将类中属性私有化，通过对外提供 set/get方法的方式，设置set属性值或获取get属性值。
	c. 将类中的方法私有化，仅内部调用。
	...
	
（2）
	class A extends B{ }
	继承性（Extends）：子类A继承父类B，代码复用，减少冗余。
	a. 一旦继承父类，则子类获取父类中声明的所有属性、方法。
	b. 关于private属性/方法：认为子类获取到了，但是由于封装性的影响，子类不可以直接调用。
	c. 所有类都直接/间接继承于java.long.Object类


（3）多态：主要指对象的多态性，new对象的时候可以直接new子类对象。
		class Person{
			method();
			...
		}
		class Man Extends Person{
			@Override
			method();
			...
		}
		class Woman Extends Person{...}

		Person p = new Person(); // 正常情况下new对象
		Person p2 = new Man();//多态：父类的引用 指向 子类的对象。
		Person p3 = new Woman();//多态

		p2.method();//编译时调用父类中的方法，实际执行时是子类中重写的方法。
		//只适用于方法，不适用于属性。

7、关键字 this

(1) this 调属性/方法：指当前对象的...（当形参和实参的属性名一样时，用this区分形参与属性）

	public void setName(String name){
		this.name = name，当前对象的name被赋值为name.
	}

(2) this调用构造器：
	a. 用this(参数)的形式调用本类中其他的构造器。
	b. 且只能在构造器中的首行！
	c. 一个构造器中只能有一个。

8、关键字 package / import

(1) package：方便项目中类的管理。使用：写在源文件的首行。
(2) import：导包，包下的类/接口都可以使用。

9、关键字 super

区分子类重写的方法 与 父类中的方法。（属性、构造器）
	class B{
		method();
	}
	class A extends B{
		@Override
		method();
	}
	
	super.method() ：父类中的method()
	method() ： 重写的 method()

10、关键字 final

final 修饰 类、方法、属性（属性、局部变量）
（1）final 类：此类不能被继承。（字面上意思为最后一个类）
（2）final 方法：此方法不能被重写。
（3）final 属性：常量。（可以放的位置：显式初始化、代码块中初始化、构造器中初始化。）
（4）final 局部变量：常量。
（5）final 形参：常量。实参传入后，在类的方法中，形参的值不可以被改变。

11、基本数据类型、包装类、String类 转换

（1）基本数据类型--->包装类：调用包装类的构造器。

	a.错误写法
	int i=10; 
	i.toString();//ERROR
	
	b.正确写法
	int i=10; 
	Integer i = new Integer(i); 
	i.toString(); // 包装类

	c. 另一种方法（JDK5.0 新特性）：自动装箱
	int i1 = 10;
	Integer i2 = i1; //包装类

（2）包装类---->基本数据类型：调用xxxValue()方法。
	
	a. 方法1
	Integer i1 = new Integer(10);
	int i2 = i1.intValue(); //整型

	b. 方法2：自动拆箱
	Integer i1 = new Integer(10);
	int i2 = i1; //整型

（3）包装类、基本数据类型--->String类
	
	int i = 10;
	
	// 方法1
	String str1 = i + ""; // 连接运算
	
	// 方法2
	String str2 = String.valueOf(i); // 调用String类的valueOf()方法。

（4）String类--->包装类、基本数据类型：调用包装类的parseXxx()方法。
	String str = "123";
	int i = Interger.parseInt(str); // String--> int 
	
	String str2 = "true";
	boolean t = Boolean.parseBoolean(str2); // String--> boolean

12、抽象类、抽象方法 abstract

（1）父类设计的很抽象，没有具体的实例，这样的类叫做抽象类。
	abstract class Person{...}
	这样的类 不能new出来对象（不能实例化）。但是类中仍然有构造器，便于子类实例化时调用。

（2）抽象方法，方法没有方法体，不能继承的类直接调用。
		abstract public void study();
		
		想要调用：（1）方法重写；（2）继承的类设置为抽象类

13、接口 interface

接口和类 是两个并列的结构
（1）类 只能 单继承。
（2）接口 由类实现，一个类可以实现多个接口。（达到多重继承的效果）
（3）

	接口通过类实现。
		class AA extends BB implements CC, DD, EE{
			...
		}

go on

先去写论文，过段时间看。