my_core_java第一周知识点总结

day1：
java : 编程语言
第一代 : 机器语言
0101 --> 计算机底层能识别 可以操作计算机 但是可读性不好
第二代 : 汇编语言
使用指令代替 0101 机器码
第三代编程语言:
面向对象编程语言
[以对象为最小单位进行编程]
编程语言:
[使用编程语言操作计算机处理数据，利用计算机的快速运算能力, 解决一些实际问题]
重点 : 处理数据

java编程语言包括:
1,数据结构:数据在内存中什么存放
二叉树,栈和队列,链表,数组,hash表
2,算法 : 处理数据时的最优解决方案
3,内存 : 开辟内存空间 销毁内存空间

java = javaSE + javaEE + javaME

使用:
1,安装jdk :
类库,jvm虚拟机,解析程序
jdk = jre + kit
2,jre : java runtime 环境
3,sdk

javac编译:
把源代码 转换 为字节码
java运行:
字节码 -->jvm–>机器码–>底层运行

顶级元素
class : 当前是一个类 一个源文件.java 只能有一个public修饰的类
并且类名和文件名需要一致
一个源文件.java可以由多个class 但是只能有一个class被public修饰
package :
包 :
package写在源文件的第一行
作用:装 .java 源文件
: 区别可能同名的源文件
: 可以把具有相同/类似功能的类放到同一个包中
具有package的源文件，编写，编译，运行
编译:javac -d bin src/Test1.java
-d:把编译以后的.class文件放到指定目录下(bin)
运行:java -cp bin com.briup.ch2.Test1
-cp:运行指定目录中的类
这个目录可以是文件夹，也可以是jar包
import 导入: (导包)
当前类中使用Test1
ch1/Test1.java
ch2/Test1.java

day2：

**注释:编译的时候会删除所有注释
//
/
/
文档注释:使用javadoc生成api
/
@param
@return
@author
@version
*/
空格 :
分隔关键字;类型 和 变量名;
优化代码格式
代码块 :
代码需要写到代码块中，有名字的代码块就是方法。

标识符
package名:全小写
类名:首字母大写,剩下的单词驼峰命名法则
方法名:首字母小写,剩下的单词驼峰命名法则
变量名:首字母小写,剩下的单词驼峰命名法则

**数据类型:**规定数据在内存所占用的空间
基本数据类型: 0101 4bit
*byte 字节 8位 bit
0000 0000
1111 1111 -128
0111 1111 127
short 短整型 16位
*int 整型 32位 10
*long 长整型 64位 10L
*float 单精度浮点型 32位 10.11f
*double 双精度浮点型64位 10.11
boolean true false

  char    两个字节表示一个字符 16位   一次只能表示一个字符
	数字   字母    普通字符   中文汉字
    表示特殊字符: 使用转义字符[\]将特殊含义的字符转换为没有特殊含义的普通字符
  char a = '\'';
  char a = '\\'

引用数据类型:
类类型:
String msg = “tom”;
接口类型
数组类型

变量 : 用来承载一个数据
为了后期操作数据方便
声明变量:
数据类型 变量名;
给变量赋值:
变量名 = 数据类型对应的值;
使用变量:
syso(变量名);
简写 :
数据类型 变量名 = 数据类型对应的值;
同时声明多个变量:
数据类型 变量名1,变量名2,…;
同时声明多个变量并且赋值
数据类型 变量名1=值,变量名2=值…;

数据类型的转换问题:: 位数越大 大
大 转 小 : 强制类型转换
int a = (int)10L;
小 转 大 : 隐式类型转换
long a = 10;

在java 运行的时候可以传递参数
java -cp bin com.briup.ch2.Test7 tom lisi wangwu
System.out.println(age+"-"+name);
++
int a = 10;
a++;
++a;
int b = a++;//10
int b = ++a;//11
逻辑运算符:
&
&&
true & true --> true
true & false --> false
false & true --> false
false & false --> false
&& 短路效果,当&&左边的表达式已经能确定整个表达式的结果时，
&&右边的表达式不执行。
(左边) && (右边)
|
||
true | true --> true
true | false --> true
false | true --> true
false | false --> false
|| 短路效果,当||左边的表达式已经能确定整个表达式的结果时，
||右边的表达式不执行。
(左边) || (右边)
! 非 ，取反
! true --> false
!false --> true

位运算符 1true 0false
& 与
0000 0000
0000 0100
----------&
| 或
0000 1010
0000 0000
-----------|

^	
0000 1010
----------- ^
1111 0101

<<  有符号左移 : 等价于乘法 
  补0
  int a = 8;
  int b = a<<i;//32
  int b = a*2^i;

   第一位是符号为 0 正数
		 1 负数
    符号为不参与运算

>>  有符号右移 等价于除法
  正数 补0
  负数 补1
     12>>i = 3 
 12/2^i = 3

<<<	 无符号左移
>>>  无符号右移
      全部补0
 12 
 12>>>1
 0000 0000 0000 1100
  0000 0000 0000 110

三目运算符 :
(boolean表达式)?()?)
int a = (true)?(10):(20);

day3：
if循环
if(){}
int a = 10;
if( (a>5) && (a++>1) ){
代码1
}
syso(a);
if(){}else{}

int a = 10
if(a<10){
a
}else if(a<20){
b
}else if(a < 30){
c
}else if(a < 40){
d
}else{
e
}
switch循环
switch(变量){
case 值 : {
break;
}
case 值 : {
break;
}
default:{
}
}
当某一个case匹配成功以后，接下来所有的case都会匹配成功，指导最后跳出switch语句
使用break可以解决 上面问题。

day4：
数组 :
承载数据,承载一堆相同类型的数据.
1，可以存放任意数据类型
2，数组的长度一经确定就不能修改。
3，下标，从0开始，方便操作(取值,赋值)数组某个位置的数据
最大下标，length - 1
数组
int[] arr = new int[5];
arr[0] = 10;
数据类型[] 变量名 = new 数据类型[长度];

排序 : Arrays.sort(数组名);

java.lang 下的类不需要导包

随机数 ：
一: java.lang.Math.random();

    二: java.util.Random;
    Random r = new Random();
    r.nextInt(10);

可变参数 :
可以接受任意多个数据
只能位于方法参数的最后一个
可变参数的使用等价于 数组

***

day5：
面向对象*
第一部分：面向对象编程
***(Object-Orientation,简称OO)是一种系统建模技术/编程思想
OO:面向对象,是一套集编程思想,方法,原则,模式,解决方案等为一体的编程模式。
OO的思想贯穿于整个软件开发的过程,比如需求分析,设计,编程,测试,升级等.
知识点速记:面向对象就是以类和类之间的关系去考虑 需求,编程…等。
1,oop解释：按照面向对象的思想进行编程
2,明确的需求:
2.1:问题域:当前的业务作用范围。
2.2:核心任务:最主要的功能
3,面向对象编程的特点:抽象,封装,继承,多态

第二部分:面向对象编程的四个基础特点之抽象
1,抽象:忽略掉一个对象或实体的细节
而只关注其本质特征的过程。
【抽象是为了得到 类(模板) 】

2,抽象需要解决的两个事情:
	2.1:抽象出Xxx的属性
	2.2:抽象出Xxx的行为
3,抽象完成以后得到的就是 类-->所有Xxx的模板

第三部分:类和对象的概念
1,类
1.1:万物皆可以抽象:
问题领域中的实体和概念都可以抽象得到对应的类。
1.2:类是啥:类是java中一种复杂的数据类型
1.3:类的作用:
1.3.1:描述数据 : 属性
1.3.2:操作数据 : 方法
知识点速记:类使用成员变量描述数据(没有具体的值)，使用方法操作数据。
1.4:类是元数据:描述数据的数据,因为数据在面向对象领域里以对象的形式存在，所以类是对象共有属性和方法的抽象描述。

2,对象
具有类中所有的属性和方法,
属性值可以不同，
方法实现可以不完全一样，
具有相同属性和行为的一组个体–>对象

2.1:类是模板,对象是该模板产生的一个个体。
2.2:个体的作用:
这个个体,可以【调用】自己的【方法】操作数据。
这个个体,可以给成员变量【赋值和取值】。

特殊对象 : 只用来存储有关联关系的数据
           javaBean  没有操作数据的方法
特殊对象 : 只用来操作数据的
	   service 只有方法;
特殊对象 : 用来和数据库交互
	   dao 

小节:对象是在程序中可以使用的单位，
对象中又包含很多数据，
所以，java程序的运行是各种对象的相互交互作用。

day6：
第四部分:类中属性和方法的定义和使用
1,属性
1.1:在类中声明属性:
语法: 修饰符 类型 变量名
修饰符 类型 变量名 = 值;

public 公有的,
       都可以访问
protected  保护 : 只有子类能访问
private    私有的:  只有当前类内部能使用
不写       默认的: 只能在当前包中访问

注:类的成员变量可以不给初始值，会有默认值。

2,方法
2.1:声明:类中方法的声明:
语法: 修饰符 返回值类型 方法名(参数列表)
[throws 异常类型]{

//代码体
//如果返回值类型不为void那么必须有
return 返回值类型的数据;

}
参数列表:用来声明变量，
声明的变量可以i在当前方法中使用
[没有赋值]

2.2:使用:类中方法的使用(调用).
语法:对象.方法名(参数列表对应类型的值);
eg:
类 对象名 = new 类();
对象名.show(10);//①
那么执行①的时候 就会去执行show方法中的代码。
调用方法时候传入的10 是实际参数。
注意:对象调用方法，只有这个方法是属于该对象才能被调用到。

知识点速记：方法声明参数的是形式参数
调用方法时传入的参数是实际参数。

第五部分:参数传递
参数传递传的是当前值在内存中的【地址】。
先看内存图:
1, 学习java中内存机制:
2,对照ch05/ParamDemo1.java代码对照内存机制运行代码。
3,参数传递:传基本数据类型
4,参数传递:传字符串
5,参数传递:传对象
6,参数传递:传数组

第六部分:this关键字
1,解释:当前对象
2,作用:
2.1:区分成员变量和局部变量
2.2:调用类中方法(什么权限的都可以调用)
2.3:调用构造器,注:this调用构造器不会重新创建对象
3,注意:静态方法中不能使用this关键字
第一部分:面向对象编程的四个基础特点 : 封装 : ch06/Encapsulation.java
1,属性的封装 : 将类中的数据【隐藏】
主要属性的访问权限进行控制
public 任何对象可以方法
protected 当前类对象和子类对象可以访问
private 只能在当前类中访问

	发现问题:如果属性加上了private修饰，那么这个属性在其他类中都无法访问。
	解决: 

2,方法的封装 : 将类中方法的具体实现隐藏
为了提高代码的重用

第二部分:方法的重载
1,定义:
【方法名相同】，
【方法的参数列表不同】
不讨论返回值 , 的多个方法 这些方法被称为方法的重载
ch06/Overload.java
参数列表不同：
个数和数据类型的排列都不一样

2,好处: 给用户对功能的调用和使用提供了很大的灵活性
注 : 重载可以是和父类中的方法进行
知识点速记:方法名相同和参数列表不同的方法就是方法的重载.

第三部分:构造方法
1,定义：在类中 方法名和类名一致，没有返回值的方法就是构造方法.
2,作用:
2.1:给属性初始化值
2.2:配合new关键字创建对象
3,小问题:
3.1:类中不写构造方法时，会有默认的构造方法 ,无参构造方法
3.2:类中手动编写构造方法以后，类中不会有默认的构造方法
3.3:在构造方法中可以调用其他的构造方法 ， 其他的构造方法必须在第一行
3.4:构造方法可以重载

第四部分:对象的创建和初始化
1,对象的创建 : 以类为模板创建个体
语法: 类名 变量名 = new 构造器;
内存中过程:
1.为对象分配内存空间，
将对象的实例变量自动初始化默认值；
2.如实例变量显示初始化，
将初始化值赋给实例变量(把默认值覆盖掉)；
3.调用构造方法；
4.返回对象的地址值；
class Student{
private int id = 30;
}
id = 0;
id = 10;

2,对象的初始化:
使用有参数构造器给对象进行初始化
类名 变量名 = new 类名(参数列表);
class Student{
private int id;
private String name;
public Student(int id,String name){
this.id = id;
this.name = name;
}
}
main(){
new Student(1,“tom”);
}

第五部分: 面向对象编程的四个基础特点 : 继承
1,一个类想具备某些特殊功能，可以继承具有特殊功能的父类，从而达到效果。
2,语法:
public class Zi extends Fu{}
3,特点:java中是单继承。
如果不写extends某一个父类，
那么所有类都默认继承Object

4,父类中什么会被继承:
1,父子类同包，子类继承父类中public、protected和默认访问级别的成员变量和成员方法；
2,父子类不同包，子类继承父类中public、protected的成员变量和成员方法；
3,构造器不能被继承
4,方法和实例变量可以被继承

5,子类构造器隐式地调用父类的默认无参构造器;
	public class Z extends F{
	  public Z(){
		
	  }
	}
	public class F{
		
	}

6,如果父类中没有定义无参构造器，只定义了有参构造器，那么子类构造器则必须显式地调用父类的有参构造器(通过super(…))，且必须放置在第一条语句，否则会有语法错误。
7,this()和super()在构造器中都必须为第一条语句，两者不能同时出现。
8,当一个子类继承了一个父类后，父类中所有的字段和方法都被子类继承拥有，子类可以任意的支配使用，每个子类对象中都拥有了父类中的所有字段。当构造一个子类的实例对象时，该对象的实例变量包括了子类本身以及父类中的所有实例变量，实例方法也包括了子类和父类中的所有实例方法。
9,子类构造器用来初始化子类中所有的实例变量，而父类构造器super(实参)用来初始化父类中所有的实例变量。所以在堆中为子类实例对象分配的内存区域中包括了子类和父类中所有初始化后的实例变量

5,继承现象大总结：
1. 子类重写父类方法，调用子类方法；
2. 子类属性与父类同名(不管子类属性前修饰符如何均允许)，如获取属性，看获取属性方法位置，如在父类中，获取的是父类属性，如在子类中，获取的是子类属性；
3. 子类私有方法与父类私有方法同名，如调用该方法，看私有方法被调用的位置，如在父类中，调用的是父类方法，如在子类中，调用的是子类方法；
4. 子类静态方法与父类静态方法同名，子类静态方法屏蔽父类静态方法。如调用该静态方法，看实例化对象时所声明的类型，如声明为父类，调用的是父类中静态方法，反之是子类中静态方法。

day7：
第一部分:方法的重写
1,重写发生在子父类中，在同一个类中方法只能被重载，不能被覆盖。
2,特点:方法名 参数列表 需要保持一致,异常不能被放大，权限不能被缩小。
3,静态方法不存在重写这一说法:子类可以定义与父类的静态方法同名的静态方法(但是这个不是覆盖)
4,父类中静态方法不能被子类覆盖为非静态方法
5,父类的非静态方法不能被子类覆盖为静态方法；
6,抽象方法：
a. 父类的抽象方法可以被子类覆盖为非抽象方法： 子类实现父类抽象方法；
b. 父类的抽象方法可以被子类覆盖为抽象方法： 重新声明父类的抽象方法；
c. 父类的非抽象方法可以被子类覆盖为抽象方法；

第二部分:super关键字
1,作用:调用和区分子类和父类的方法
子类中调用父类中的方法或者构造器或者成员变量
调用方法: super.show();
调用构造器: super(参数); 只能位于构造器第一句

2,子类构造方法中如没有使用this关键字，会隐式调用父类的无参构造方法

第三部分:面向对象编程的四个基础特点 : 多态
父类的引用指向子类的对象
父接口的引用指向实现类的对象

多态的好处:代码更加灵活

多态出现在 具有继承关系的两个类对象之间，
语法: 父类 变量名 = new 子类();
      接口 变量名 = new 实现类();

使用多态的对象调用方法时:
编译: 看父类中是否有这个方法/接口中是否有这个方法
运行: 执行具体实现类中的方法

第四部分:引用数据类型的 转换

隐式转换 : 小类型转换为大类型
	Student stu = new Student();
	Object obj = stu;//正常
强制类型转换: 大类型转换为小类型
	PoFu f = new PoFu();
	PoZi z = (PoZi)f;//错误

	PoFu f = new PoZi();
	PoZi z  = (PoZi)f;//正确

得到结论:只能强制转换为 对象的实质数据类型