小白自学java总结

复习Java总结

java 的特性

简单性
面向对象
可移植性
高性能
分布式
动态性
多线程
安全性
健壮性

• jdk包含了jre包含了jvm
• jdk在jre之上扩增了开发 工具
• jvm是java虚拟机

c语音编译型的

java是既编译又解释型的

源程序.java文件通过Java编译器形成.class文件
通过jvm虚拟机的类装载器到字节码校验器到解释器最后到操作系统

• 单行注释 //
• 多行注释 /* */
• 文档注释 /** */

标识符

• 关键字

Java中所有的组成部分都需要名字。类名变量名以及方法名都被称为标识符。

程序规范

类成员变量：首字母小写和驼峰原则：除了第一个单词以外，后面的单词首字母大写
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则：Man，GoodMan
方法名：首字母小写和驼峰原则：runRun()

语言基础

数据类型(四类八种)

• byte1,short2,int4,long8,float4,double8,char2,boolean 1

引用数据类型

• 类 接口 数组（string）

修饰符

• 没有顺序

访问修饰符
default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。

private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）

public : 对所有类可见。使用对象：类、接口、变量、方法

protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

字符串

• 字符串连接符号 +

//字符串在前面，后面拼接
System.out.println(""+a+b);
/字符串在后面，先运算后拼接
System.out.println(a+b+"");

量

• 常量(final):常量存储的是在程序中不能被修改的固定值，也就是说程序运行的整个过程中保持其值不变的量。final int A = 20;
• 变量：就是可以变化的量，JAVA变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。
• 局部变量：只在方法中。必须声明和初始化值，首字母小写和驼峰原则
• 实例变量：在类中在方法外面，从属于对象，new类对象在方法中进行调用，从属于对象，如果不自行初始化，这个类型的默认值为0或0.0。布尔值为false，除了基本类型其他的的默认值都为null。
• 类变量(static)：也叫静态变量。从属于类中。随类一起开始，一起消失。在类中可以直接调用。

数据类型的转换

• 隐形转换 (由小到大,小数的优先级大于整数)
• 强制转换 （由大到小)

* //(类型) 变量名
* int i =128;
* byte b = (int)i;//注意内存溢出问题
* //不能对布尔值转换
* //不能把对象的类型转换为不相干的类型
* 在范围大到范围小转换为强制转换
* 注意内存溢出和精度问题

运算符

• 计算的先后案例

public static void main (string[] args){
    int a =3;
int b =att;
int c =++a;
System.out.println(a);
System.out.println(b);
System.out.println(c);
a=5;b=3;c=5;

• Math 是数学类
• 三元运算符

//x?y:z
//如果x==true,则测试为y，否则为z
int score = 50;
String type = score<60 ?"不及格":及格
System.out.println(type);
不及格
//比较大小
int a=10;
int b=20;
int c=30;
//条件表达式？a：b 如果条件表达式为true则取a否则取b
int type = (a>b)?a:b ;
int max = (type>c)?type:c
System.out.println(max);

• 逻辑运算符
• 与 && 两个都为真结果为真
• 或 || 两个有一个为真 结果为真
• 非 ！ 如果是真结果是假，如果是假结果为真

javados

• 在黑窗口中 通过命令 javadoc 参数 Java 文件

java流程控制

• 用键盘输入数据（scanner）

public static void main (string[] args){
//创建一个扫描器对象，用于接收键盘数据
Scanner scanner = new Scanner(sytem.in);
//判断用户有没有输入字符串
     //用next方法接收，next()不能得到带有空格的字符串
String str = scanner.next();
System.out.println("输入的内容为"+str)
//凡是使用IO流的类如果不关闭回一直占用资源
scanner.close();
 //nextLine()方法返回是输入回车之前的所有字符，可以获得空白 这个方法比较好，可以接受长字符串
}

• 顺序结构

选择结构

分支结构

• if条件语句

//单选结构
if(布尔表达式){
    如果为true则执行语句
如果为false跳过语句执行下一种语句
}
//双选结构
if(score>60){
    System.out.println("及格")
}else {
    System.out.println("不及格")
}
//多选择结构
if(60<score<70){
System.out.println("D");
    }else if(70<score<80){
    System.out.println("C");
    }else if(80<score<90){
    System.out.println("B");
 }else if(90<score<100){
    System.out.println("B");
}

• switc多h选择语句

char grade ='c';

//匹配一个具体的值

switch(grade){
//case 穿透
case 'A'：
     System.out.println("优秀");
break; //可选 关门
case 'B':
System.out.println("中等");
break; 
case 'C':
System.out.println("挂科");
break; 
//如果没有匹配到，则输出default
default:
System.out.println("没有成绩");
}

循环结构

• while语句

while(布尔表达式){
    //只要为ture循环会一直走下去
    //死循环 为false 就结束
}
//do while循环(即使不满足布尔表达式，也能执行一次) 至少执行一次
do{
    //代码语句
}while(布尔表达式);
//while 总是先判断后执行
//dowhile总是先执行后判断

• For循环

for(初始化;条件判断；更新){
    //代码语句0
}

• 增强for循环

//主要用于数组和集合中的遍历使用
for(声明语句：表达式){
    //语句
}

//定义一个数组（用for循环遍历）
int [] numbers = {10,20,30,40,50}
for(int x : numbers){
    System.out.println(x);
}

循环中的三种跳转语句

• break语句 (强制退出循环，循环结束，程序可以继续输出)
• continue 语句(终止某次次循环，执行下一次是否循环的判定)
• return 已经返回结果代表方法结束

方法

• 方法是解决一类问题的步骤的有序组合
• 方法含于类或对象中
• 方法在程序中被创建，在其他地方被引用

修饰符 返回值类型 方法名(){
    ----
 方法体
 ---
return 返回值;
///return除了返回，还有终止方法的作用。
}
参数类型：参数像是一个占位符，当方法被调用时，传递值给参数，这个值被称为实参或者变量，参数列表是指方法的参数类型，顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
1.形式参数：在方法被调用时用于接收外界传入的数据
2实参：调用方法时实际传给方法的数据

方法调用

• 调用方法：对象名.方法名(实参列表)当方法返回一个值的时候，方法调用通常被当做一个值
• 如果返回值时void 方法调用一定是一条语句

方法的重载

*可以让程序清晰易读
*方法名称相同
*通过改变参数列表(个数不同，类型不同，参数排列顺序不同)

可变参数

//Java支持传递同类型的可变参数给一个方法
//在方法声明中，在指定参数类型后加一个省略号(...)
//一个方法中只能指定一个可变参数，他必须是方法的最后一个参数，任何普通的参数都必须在它之前证明。
public static void 

递归

• 递归就是A方法自己调用自己
• 但是占用大量的栈内存。
• 能不能用就不用

//案列阶乘
package Demo;

public class Demo02 {
public static void main(String[] args) {
	System.out.println(f());
}
public  static int f (int n) {
//边界条件
	if(n==1) {
		return 1;
		//前阶段：调用自身
	}else {
	//返回阶段
	return n*f(n-1) ;
	}
}
}

数组

• 数组的概念

数组是相同类型数据的有序集合
数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
每一个数据成为一个数组元素，每个数组元素可以通过一个下标来访问他们。

*数组的声明

模板：dataType[] arrayRefVar = new dataType[arraySize];
int[] nums; //1.定义
nums = new int[10];//2.可以存10个数据(分配空间)
//3.给数组元素中赋值
nums[0]=1;
---
nums[8]=9;
nums[9]=10;
//计算所有元素的和
int sum =0;
//获取数组长度：arrays.length

• 数组的使用

package Demo;

public class Demo03 {
public static void main(String[] args) {
	int [] arrays = {1,2,3,4,5};
	//没有下标 一般用于遍历结果
	for(int array : arrays){
		System.out.println(array);
	}
}
//打印数组元素 printArray

public static void printArray(int[] arrays) {
	 for(int i=0;i<arrays.length;i++) {
		 System.out.println("arrays[i]"+"");
	 }
}
}

• 多维数组

• Arrays类

int[] a = {1,2,3,4,5}
//打印数组元素 toString
System.out.println(Arrays.toString(a));

面向对象编程

• 面向对象编程的本质就是：以类的方式组织代码，以对象的组织(封装)数据。
• 面向对象与面向过程

//面向过程思想
步骤清晰简单，第一步，第二步
//面向对象
物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
// 类：抽象的，实例化
// 类实例化后会返回一个自己的对象！
// student对象就是一个Student类的具体实例
Student student = new Student();

类与对象

• 类与对象的区别

类：类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。
对象：对象是抽象概念的具体实例，能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。
从认识论角度考虑是先有对象后有类。对象，是具体的食物。类，是抽象的，是对对象的抽象。
从代码运行角度考虑是先有类后有对象。类是对象的模板。

构造器

//一个类即使什么也不写，也存在一个无参构造，一旦定义了有参构造，无参就必须显示定义
 //使用new关键字本质是调用构造器
//先走一遍Person类的构造器，再生成对象  
//用来初始化值
Person person = new Person();
//必须和类名相同，没有返回值
//实例化初始值用this. 
//有参构造
package Demo;

public class Demo04 {
   int age;
   String name;
public Demo04(int age,String name) {
this.age=age;
this.name=name;
}
public static void main(String[] args) {
   Demo04 d = new Demo04(19,"man");
   System.out.println(d.age);
}
}

创建对象内存分析

//创建一个对象
Pet dog = new Pet();
//main方法在栈内存中
//dog作为一个引用变量名在栈内存中
//具体的对象new Pet();在堆内存中
//static在堆里的特殊的静态方法区中、，随类一起加载，一起消失。

封装(该封的封，改装的装)

程序设计追求"高内聚低耦合"，高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合:仅暴露少量的方法给外部使用
1,提高程序的安全性，保护数据
2，隐藏代码的实现细节
3，统一接口
4，程序的可维护性增加了
// 属性私有
//get 获得这个属性
//set 给这个数据设置值

继承

• extends
• object类
• super

1.super调用父类的构造方法，必须在构造方法的第一个。
2.super必须只能出现在子类的方法或者构造方法中！
3.super和this不能同时调用构造方！
super与this不同点：
(1)：代表的对象不同。
this：本身调用者这个对象。
super： 代表父类对象的引用。
(2)：前提
this：没有继承也可以用
super：只能在继承条件才可以使用。
(3).构造方法
this(); 本类的构造
super(); 父类的构造！

• 方法重写:就是方法的重写与属性无关
• 什么要重写：父类的方法子类不一定需要，或者不一定满足！

//重写的是非静态方法
//方法的调用只和左边定义的数据类型有关
AextendsB
 父类的引用指向子类
 B b = new A();
 * 方法名必须相同
 * 参数列表必须相同
 * 修饰符范围可以扩大，但不能缩小
 *抛出的异常范围可以被缩小，不能扩大。
 * 返回值可以不同，但必须是父类的衍生。

• 1.extends 的意思是"扩展“。子类是父类的扩展 。
• 2.JAVA中类只有单继承，没有多继承！
  3.继承是类和类之间的一种关系。除此之外，类和类之间的关系还有以来，组合，聚合等。

多态

1.即同一个方法可以根据发送对象的不同而采用多种不同的行为方式

 注意事项；
 1.多态是方法的多态，属性没有多态。
 * 2.父类和子类，有联系，类型转换异常。
 3.存在条件，继承关系，方法需要重写。父类引用子类对象
 Father f = new Son();
 //static 方法属于类 不属于实例不能重写
 //final 常量不能重写
 //private 私有方法不能重写

• instanceof 和类型转换。

Sys.out.println(X intanceof Y)//判断吗x和y是否有继承关系
Person obj = new Student();
//student将这个对象转换为Student类型，我们就可以使用Student类型的方法了！
Student student = (Student)obj;
student.go;//这时就可以调用子类的go方法。
//子类转换为父类，可能会丢失自己本来的一些方法!
1.父类引用子类的对象
2.把子类转换为父类，向上转型。
3.把父类转换为子类，向下转型，强制转换。
4.方便方法的调用，减少重复的代码。

static总结

 *随类一起加载，随类一起消亡
 *可以通过类名引用 类名.静态变量名
 *可以通过实例对象引用 对象名.静态变量名
 //static的方法只能访问static成员或者调用static成员方法，或者在静态方法中不能访问实例变量与实例方法
 //非静态方法，可以调用静态方法。
 类名.静态变量名();
 对象名.静态方法名();

抽象类

abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类。
抽象类，不能使用new关键字来创造对象，它是用来让子类继承的。
抽象方法：只有方法的声明，没有方法的实现，他是让子类来实现的。
子类继承抽象类：那么就必须要实现抽象 类没有实现的抽象方法，否则该类也要声明为抽象类。

• 接口(定义 实现 引用 继承)

//接口只有规范 自己无法写方法。 
//定义
 interface 类名
 接口中的所有定义其实都是抽象的
//类可以实现接口 implements
 实现 接口的类 必须要重写接口中的方法。
 

• 匿名内部类

• 异常处理(捕获与抛出)

线程(5大)

*新建
*就绪
*运行
*阻塞
*消亡
*什么是进程 什么是线程
*泛型与容器