java入门基础（二）重温java获得的新知识

这两天的java知识总结，写的都是大家平常容易忽略过的东西，一直在保持更新
希望能够对大家有一些用处
基本三天发布一篇，或者更新一篇
有错误的话提问出来，这只是我对java的理解

一、数据类型

*Java中的数据类型分为两大块

基本数据类型又常叫8大基本数据类型

八大基本数据类型
整数 byte short int long
小数 float double
字符 char
布尔类型 boolean
*注意 在声明long和 double数据类型的时候要加上L或D 大写小写都可以
几种数据类型所占的字节和取值范围

类型转换

自动类型转换的条件：
一：两种类型互相兼容
二：目标类型小于源类型
自动类型转换规则

例子：

byte a = 0;
                int b = a;
                long c = a;
                float d = a;
                double e = a;
System.out.println("b="+b);
               System.out.println("c="+c);
               System.out.println("d="+d);
               System.out.println("e="+e);

结果为：从小的类型转为高的类型，byte转int,long,float,double 得出结果：0 0 0.0 0.0

强制类型转换
在要强制转换类型的前面加上括号，然后再括号里面加上你要转换的类型。
在把容量大的类型转换为容量小的类型时必须使用强制类型转换

a+=2于a=a+2的核心区别
前者不会发生自动类型提升，后者会发生自动类型提升

表达式与运算符

1. 算数运算符：对两个变量做算数运算
   5种：加+ 减- 乘* 除/ 模%
2. 算数运算符：一元运算符
   2种：自增++，自减–
3. 赋值运算符：
   1）= 2）*= 3）-= 4)/= 5)%=只有等于会发生自动类型提升
4. 关系运算符： 对两个变量或字面值进行比较，结果为boolean值

大于
< 小于
= 大于等于
<= 小于等于
== 等等
!=

5. 逻辑运算符 ：对两个boolean值或布尔表达式做判断
   运算符 语义
   描述
   && 逻辑与 对两边的布尔表达式做判断，若同时为真，则整个结果为真；若有一个为
   false，在整个结果为false;
   || 逻辑或
   对两边的布尔表达式做判断，若有一个为真，则整个结果为真；若同时为
   false，则整个结果为false;
   ！ 非 取反，对真取反，则为假；对假取反则为真
   

6. 三元运算符
   .

二、分支结构

if分支

四种表述方法

1. if
2. if … else
3. if … else if
4. if … else if … else if… else
   else后面可以跟一句不加括号的话，必须能把逻辑表达清楚的话才能跟，比如输出语句

switch分支

Swich语句分支可以表达的if语句一定可以表达

switch（int）{
case 0：System,out.println(1);break;
case 1：System,out.println(2);continue;
Defaoult:exit(0);
}

JDK7.0之后字符串也可以用swich,只不过必须做好值的精确匹配

for循环

又叫确定循环，提前设定好条件
for（；；）{
}这个也是对的。
在
我的理解中for循环叫做不确定循环的原因它可以设定终止条件break随时从循环内蹦出来。

while循环和do while循环

//while语句
while( 布尔表达式 ) {
  //循环内容
}

//do while语句
do {
       //代码语句
}while(布尔表达式);

—do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。

break和continue

break跳出当前循环
continue 跳出本次循环

关于循环的起名问题

Loop:for{
For{
			Break loop;//两个循环全部出
   }
}

三、一些零碎知识点

局部变量
1：只在声明在函数内部 必须先赋值在使用；
2：有作用范围，当前的代码块可以使用
3：全局变量可以和局部变量重名，以局部变量为主;
IF() System.out.println();如果if后面不加大括号的话，后面只能有一句代码；

穷举思想

利用计算机的计算速度的优势，把所有的可能结果列出来，找出我们需要的结果
百钱买百鸡：要考虑优化问题，可以大大增加速度；
写循环时要找出两者之间的规律

四、函数

函数：本质上，提升我们的方便，可维护，易理解，代码减少
概念：实现特定功能的一段代码，可以反复使用
例子：public static void 函数名称（）{} public static 返回值类型 函数名
void代表无返回值类型函数。
**使用：**函数使用时在主函数中调用，调用者提供必要的数据完成相应的功能。
1）有参函数 可以有多个参数，以逗号隔开。定义参数时就是声明了一个变量
2）无参函数
**形参：**函数上的参数就是形参
**实参：**调用时传的参数是实参。为形参传递数据
return 后面的代码不再执行 直接返回
****注意：****java中不允许有执行不到的代码

递归

java是一个结构化编程语言
递归
比较难做的算法题，多半是要用递归做。
把大问题化成小问题，小问题与大问题的解决方式是一样的。给函数一个终止条件

//哥德巴赫猜想：
//任何一个大于6的偶数都能被分解为两个质数的和，要求随	//机输入一个大于6的偶数，打印它能被分解为哪两个质数的	和。
package a1;
import java.util.Scanner;
public class Text5{
	public static void main(String[] args){
			//随机获取一个整数n
			Scanner sc=new Scanner(System.in);
			int a=sc.nextInt();
			judge(a);
			for(int i=1;i<a/2;i++){
				for(int j=1;j<a;j++){
					if(judge(i)&&judge(j)&&i+j==a){
						System.out.println("质数一为"+i+"质数二为"+j);
					}
				}
			}
	}
	public static boolean judge(int n){
			boolean falg=true;
			for(int i=2;i<=n/2;i++){
				if(n%i==0){
				falg=false;
				return falg;
				}
			}
			return falg;
	}
}

五、数组

**数组：**一组连续的储存空间，存储多个相同数据类型的值数组。
**特点：**类型相同，长度固定
**New：**开辟虚拟机堆空间
在我们为数组分配空间的时候，数组就被分配了默认值0,布尔类型默认值false 对象类型默认值 null
数组的创建语法三种：
1)先声明，再分配空间

数据类型[] 数组名；
数组名=new 数据类型[长度]

2)声明并分配空间：

数据类型[] 数组名=new 数据类型[长度]；

3)声明并赋值：

数据类型[] 数组名=new 数据类型[]{value1,value2,value3}；

可变长参数数组

参数表中只能有一个可变长参数，且必须是最后一个参数
示例：

//...   a就是a数组
Public static int add(int...a){
Int result=0;
For(int i=0;i<a.length;i++){
Result+=a[i];
}
Return result;
}

数组的扩充

数组元素的地址是连续的，计算机16位储存数据
数组长度扩充思想：创建一个新数组，把旧数组的数据传入新数组

//1、定义一个长度为3的数组，将其扩容，长度是原数组的两倍。
package a1;
public class Text1{
	public static void main(String[] args){
		int a[]=new int[3];
		int b[]=new int[a.length*2];
		System.out.println(a);
		b=a;
		System.out.println(a);
	}
}

数组 链表 散列表区别

数组：查询方便，数组的插入删除变得麻烦
链表：与数组相反，查询比较慢，插入删除比较快
散列表：查询效率也高插入删除也快：缺点浪费空间

二维数组

本质上：一维数组的一维数组
声明：

int[][] a;
a=new int[4][3]

Java中独特的创建二维数组的方式
Int[][] a=new int[3][]
二维数组的低维数组长度可以不一样

数组下标为什么从0开始:

从寻址方面来说，下一个地址直接乘以第几位就行
为了方便计算，提高计算速度

六、典型的三个排序算法

冒泡排序

核心思想：两个相邻的元素去比较

/*冒泡排序 
核心思想：两个相邻的元素去比较*/
package a1;
public class Text1{
	public static void main(String[] args){
		int[] a={8,7,6,9,4,5};
		for(int i=0;i<a.length-1;i++){
			for(int j=0;j<a.length-i;j++){
				if(a[i]>a[i+j]){
					int c=a[i+j];
					a[i+j]=a[i];
					a[i]=c;
				}
			}
		}
		for(int i=0;i<a.length;i++){
				System.out.print(a[i]+"  ");
			}
	}
		
	}

选择排序法

核心思想：一个元素和其他所有元素去比较

排序算法

Arrays.sort(a);

七、面向对象

面向过程：从计算机的执行角度出发，以代码执行过程为核心
自顶向下，逐步求精，到了一定规模就比较麻烦
面向对象：
概念：从人的角度出发，从现实世界的角度出发
先确定解决问题所需的对象，再建立对象间的关系，从而确定过程
一切客观存在的事物都是对象，万物皆对象
任何对象，一定具有自己的行为和特征

对 特征：称为属性，一般为名词，代表对象有什么
象 行为：称为方法，一般为动词，代表对象能做什么
### 三种关系
对象由这几种关系组成了我们的整个世界
汽车 车 继承关系
汽车 发动机 关联关系
汽车 司机 依赖关系 司机去调用了汽车的使用方法

方法重载

在一个类中定义多个方法，方法名相同，参数表不同（数据类型不同，参数类型排列不同）
注意：不允许只能形参名不同。
编译器在编译时会根据实参的类型，选择相应的方法去调用（向上就近匹配|)
如byte类型，如果没有去找short
注意：不许出现调用不明确的；

有些情况下，对象的同一种行为可能存在多种实现过程。
重载的作用：允许类中的同类方法同名；屏蔽不同参数的差异（如println）

八、构造方法

构造方法是一种特殊的方法，它是一个与类同名的方法。对象的创建就是通过构造方法来完成，其功能主要是完成对象的初始化。当类实例化一个对象时会自动调用构造方法。构造方法和其他方法一样也可以重载。

1）不能定义返回值类型
2）方法名必须和类名相同，包括大小写。
3）不能手工调用，只能在对象的创建过程中自动创建一次

构造方法做什么：给属性赋值

九、类

在一组相同或相似的对象中，抽取出共性的特征和行为，保留所关注的部分
类的含义：是对对象共性的抽象，代表了一类事物，人对一类事物的认识。

成员变量：
类的内部，方法的内部。
可以于局部变量重名；局部变量优先

实例方法：

声明：修饰符，返回值类型，方法名（形参列表） 抛出的异常 代表了对象能做什么
实现：{代码块} 代表了对象怎么做

New类
一个类：属性，方法，构造方法
如果一个类中没有任何构造方法，默认使用无参的构造方法
其他情况下，new 类名（构造参数表）
对象类型本质上跟数据类型一样
创建对象的语法：类名 变量名=new 类名（构造参数表）
访问对象的语法：
变量名.类名
变量名.方法（实参）

十、对象类的写法

三个部分
1）属性
2）构造方法
3）普通方法

使用时：创建对象，使用对象方法
引用里存的是对象的地址
空指针异常。

面向对象的三大特性

封装

访问修饰符： 访问范围 继承性
从访问的范围由小及大依次是：private default（当什么都不写默认就是这个） protected public
访问修饰符的作用：可以修饰类、接口、属性和方法。通常可以通过访问修饰符来改变所修饰对象的可访问范围。
public
private
default 本类＋同包 同包子类可以继承
protected 本类＋同包＋子类 可以
访问方法
用来做什么： Setter:赋值 Getter:取值，在哪儿用：在构造方法中初始化属性值的用！！！！！或者对象名.set/get()进行使用！！！
set，get方法一个设置属性，一个改变属性
set方法
get方法

public String getName() {
        return name;
 }
public void setName(String name) {
        this.name = name;
}

public int getAge() {
        return age;
}

public void setAge(int age) {
        this.age = age;
}

继承

如果这句话成立：子类是 is a父类
**继承特点：**单继承，一个类只能有一个直接父类，只有这样，类之间才能形成树状结构
里氏代换原则，子类可以扩展父类的功能，但不能改变父类原有的功能。
组合/聚合复用原则定义
合成/聚合复用原则经常又叫做合成复用原则。该原则就是在一个新的对象里面使用一些已有的对象，使之成为新对象的一部分：新的对象通过向这些对象的委派达到复用已有功能的目的。
注意
构造方法不可继承
**方法的覆盖：**子类用特殊的方法实现，替换掉父类的方法
方法名相同，参数表要相同，返回值类型也要相同

一个构造方法的第一行必须是super();
默认
super();在没有指明调用父类哪个构造方法的时候，调用的是无参构造方法。

组合/聚合复用优于继承
**继承违背了开闭原则：**继承打破了封装性，子类继承父类，那么父类的实现细节将完全暴露在子类当中，随着时间的推移，如果父类发生变化将会影响子类的也发生变化，所以在使用继承前，请确保子类是否完全是超类型的子类，即判断是否is-a，如果不是请不要使用继承。

无论是组合还是聚合，它们都持有对象的引用，在不继承类的前提下可以在内部调用引用的方法，这叫做转发，降低耦合度。

适当使用组合/聚合的好处就是明确每个对象的职责，滥用继承则是结构化的思想，这是要杜绝的

多态

多态的基础是继承。
子类对象可以赋值给父类引用
1）只能对引用调用其引用类型中声明的方法
2）运行，根据对象实际类型，调用子类覆盖后的方法
3) 对象类型不变，强制类型转换，用于父类引用赋值给子类引用，无法改变对象类型。
判断引用中的对象和后面的类名是否相同 引用instanceof 类名