java自学笔记

1. 1 int类强制转换另类方法：0+变量

> public class Test2 {
	public static void main(String[] args){
		
		char a='b';
		System.out.println(0+a);		
	}

}结果为  98.

1. 2 位运算符意义之一在于加快算法效率，比如3*2可以写成3<<1,大大加快运算效率。左移一位等于 2，移两位4， 移n位相当于乘以2^n， 右移一位为 /2。

1. 3 字符串是一个对象，定义为 String = “a”(双引号),字符是一个变量，定义为 char = ‘a’（单引号）,java语言具有独特的智能识别运算功能，例如：

public class Test2 {
	public static void main(String[] args){
		String a = "3";
		int b = 4;
		int c = 5;
		char d = 'a';//字符a的ASCLL码为97
		System.out.println(a+b+c);
		System.out.println(c+b+a);
		System.out.println(b+d);	
	}

}`输出结果为：			   345
						   93
						   101						   

1. 4
三目运算符

public class Test5 {
	public static void main(String[] args){
		
		int score = 70;
		String result = score >= 60 ? "及格" : "不及格";
		System.out.println(result);	
	}

}结果为及格

1. 4.1自增符号++、- - 与+=、-=运算符
自增减符号和+=、-=符号运行时不会改变变量的类型，比如 定义一个变量short s ，想要实现自增1，写成s=s+1，则编译不通过，因为1默认数据类型为int。可以写成s++或者s+=1，顺利通过编译运行，并且s仍然为short类型。

1. 5
Java键盘读取输入，需在程序前引入 java.util.Scanner 类

import java.util.Scanner;


public class Test6scanner {
	public static void main(String[] args){
		
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入姓名：");
		String name = scan.nextLine();
		System.out.println("请输入年龄：");
		int age = scan.nextInt();
		System.out.println("************");
		System.out.println(name);
		System.out.println(age);	
	}

1. 6
方法运用 static 修饰后，可以直接在main方法里面调用。

1.7
可以使用递归的算法用循环迭代也可以解决，在不强调效率的情况下，可以使用递归。递归会占用大量的系统堆栈，内存耗用多。

1. 8 需要协作的大型软件需要用到面向对象。
对象是一个内存块，内存块里边放一些数据和方法。
通过对 对象 进行 抽象，就产生了 类class 。一个Java文件中可以定义多个类，但只能定义一个有public修饰的类。
可以在类的属性定义中直接建立另一个类的对象 ，比如直接在 class A 中定义class B 的对象

public class A{
		B b;	
	publc static void main(String[] args){

	}	
}
class B{
	System.out.println();
}

1.9 继承
java中的继承只有单继承，不像c++中可以多继承，接口可以有多继承。可以使用 Ctrl+t 快捷键 快速查看当前类的继承情况。类的默认父类为 java.lang.Object 。
继承的关键字为 extends 。instanceof 是二元运算符，用于判断对象的类型，左边是对象，右边是类名，是返回 true，不是返回 false。

package cn.sxt.oo2;

//建立主类
public class TestExtends {
	//main方法是程序运行入口
	public static void main(String[] args){
		
		Student stu1 = new Student("李白",18,"计算机");//建立一个stu1对象
		System.out.println(stu1 instanceof Person);//instanceof 运算符的运用 
	}
}
//建立Person类
	class Person {
		int number;
		int age;
		String name;
		public void rest(){
			
			System.out.println("吃饭！");
		}
	}
//建立Student类
	class Student extends Person{//因为student具有和Person相同的属性age,name
								 //和相同的方法rest，所以可继承。
		String major;//student具有person没有属性major
		public void study(){
			System.out.println("学习！");
		}
	//建立student构造方法
		public Student(String name,int age,String major){
			
			this.name = name;
			this.age = age;
			this.major = major;
			this.study();
			this.rest();//因为继承了person类，所以在student类里可以直接调用person中的方法
		}
	}//运行结果为：	学习！
					吃饭！
					true

2.0 构造方法
为了在一个类中的对象在被创建时就完成了所有的初始化工作（包括其静态属性值，含有的初始方法等），因此Java在类中提供了一个特殊的成员方法，即 构造方法。它可以为类的对象在创建时就自动调用为该对象初始化。
构造方法是一个特殊的方法，它的名称必须与类名相同，不可以设置返回值，也不可用 void 修饰，因为构造方法的返回值就是类本身。 构造方法也可以重载。为了在构造方法中调用另一个构造方法或者调用类中的成员变量（即类中构造方法代码块外的成员变量），需要使用关键字 this 进行调用。调用父类的特定的构造方法时用 super(参数，参数…) ，调用父类普通方法 super.父类方法名 。可以用关键字super来访问被子类重写覆盖后的父类方法。

2.0.1构造方法的重载
在类中建立有参的构造方法后，创建对象时就要传入相应的参数才行，否则编译会报错。这时可以在类中对有参构造方法进行重载，建立无参构造方法（因为一旦在类中主动建立构造方法后，原本默认建立的无参构造方法会被清除）。

//建立主类
public class TestExtends {
	//main方法是程序运行入口
	public static void main(String[] args){
		
		Student stu1 = new Student();//建立一个stu1对象
		System.out.println(stu1.name);
		System.out.println(stu1 instanceof Person);//instanceof 运算符的运用，用于判断对象所属，返回true或false
	}
}
//建立Person类
	class Person {
		int number;
		int age;
		String name;
		public void rest(){
			
			System.out.println("吃饭！");
		}
	}
//建立Student类
	class Student extends Person{//因为student具有和Person相同的属性age,name
								 //和相同的方法rest，所以可继承。
		String major;//student具有person没有的属性major
		public void study(){
			System.out.println("学习！");
		}
	//建立student构造方法，建立构造方法后，建立对象时如果构造方法中有参数，则创建对象时必须传入对应的参数。
	//构造方法用于对象在创建时就运行一定的动作，在对象产生时自动执行。
		public Student(String name,int age,String major){
			
			//this.name = name;
			//this.age = age;
			this.major = major;
			this.study();
			this.rest();//因为继承了person类，所以在student类里可以直接调用person中的方法
		}
		public Student(){} //对有参构造方法进行重载，建立无参构造方法
	}
	运行结果：null
             true

2.0.2 构造器中this关键字的使用
构造器中为了能够对类中的变量进行初始化赋值，或者调用类中的方法，需要通过this关键字进行调用,可以防止类中get,set方法中形参与类中属性同名带来的而属性调用不符合预期。this表示的意思为当前对象，

• this关键字可以省略，但是出现同名问题时需要加上this关键字。可以通过this、关键字在类中的构造器中调用另一个构造器。
• 使用this调用另一个构造器必须放在构造器的首行。意味着构造器内部，最多只能声明一个 this(形参列表) ，用来调用其他构造器。

//建立主类
public class TestExtends {
	//main方法是程序运行入口
	public static void main(String[] args){
		
		Student stu1 = new Student("立绘",19,"computer Technology");//建立一个stu1对象
		System.out.println(stu1.name);
		System.out.println(stu1.age);
		System.out.println(stu1.major);
		System.out.println(stu1 instanceof Person);//instanceof 运算符的运用，用于判断对象所属，返回true或false
	}
}
//建立Person类
	class Person {
		int number;
		int age;
		String name;
		public void rest(){
			
			System.out.println("吃饭！");
		}
	}
//建立Student类
	class Student extends Person{//因为student具有和Person相同的属性age,name
								 //和相同的方法rest，所以可继承。
		String major;//student具有person没有的属性major
		public void study(){
			System.out.println("学习！");
		}
	//建立student构造方法，建立构造方法后，建立对象时如果构造方法中有参数，则创建对象时必须传入对应的参数。
	//构造方法用于对象在创建时就运行一定的动作，在对象产生时自动执行。
		public Student(String parameterName,int parameterAge,String parameterMajor){
			
			//this.name = parameterName;//未对类中变量name进行初始化赋值，其默认结果为null
			this.age = parameterAge;//使用this关键字对类中的变量进行初始化赋值
			this.major = parameterMajor;
			this.study();//使用this关键字调用Student类中的study方法
			this.rest();//因为继承了person类，所以在student类里可以直接调用person中的方法
		}
		public Student(){} //对有参构造方法进行重载，建立无参构造方法
	}
		运行结果为：
					学习！
					吃饭！
					null
					19
					computer Technology
					true

2. 1 static关键字
用 static 修饰的变量和方法从属于类，生命周期和类相同。
用static修饰的变量称为静态变量，类中静态变量的定义必须独立于方法之外，静态变量类似于 全局变量，对于静态变量的调用 ，可以使用 类名.静态变量名， 对象名.静态变量名， 或者直接 静态变量名， 但是建议使用 类名.静态变量名 的用法。用static修饰的方法称为静态方法。***静态方法中不可以调用非静态方法。静态方法只能调用静态变量或静态方法，或者说静态方法不能调用实例变量和实例方法。***建议使用 类名.静态方法名 类调用静态方法。静态初始化块的执行顺序为 父类->子类。

3. 1 包
包中包含类，包对于类的作用，相当于文件夹对于文件。类的开头需写明 （pakage.包名） 。其他包中类的导入需要在类的开头使用关键字 （import .包名.类名） ，或者直接 （import 包名.*） 表示直接导入该包中所有的类。

4.1 方法的重载
方法都可以重载，继承过来的方法也可以重载。方法的重写返回值类型需要小于等于父类的类型。

- 5.1数组元素的默认初始化值

int数组：0
浮点型数组：0.0
char型数组：0或者‘\u0000’，而非’0’，char 0，代表空格字符，但是char ‘\u0000’，不是代表ASNC码表里的空格字符，打印出来的是空格效果。
boolean型数组：false

public class ArraysTest {
	public static void main (String[] args){
		
		//静态初始化
		int[] i = new int[]{1,33,45};
		//动态初始化
		double[] d = new double[5];
		System.out.println(i[1]);
		System.out.println(d[3]);
		char[] ch = new char[]{99,95,'\u0000'};
		System.out.println("***"+ch[2]+"****");
	}
}
运行结果
33
0.0
*** ****

• 5.2 数组数据存放的位置

• 一维数组内存解析
  数组引用类型在栈中生成，存储着数组成员在堆中生成的首地址。
  

• 数组是引用类型，可以调用方法

public class ArrayTest2 {
	public static void main(String[] args){
		
		int[] i = new int[]{1,2,3,4,5};
		System.out.println(i.length);
	}
}

运行结果为 5

• 数组的复制和反转

public class ArrayTest3 {
	public static void main(String[] args){
		
		String[] array = new String[]{"aa","bb","CC","dd","EE"};
		
		//数组的复制，区别于数组引用地址的赋值：array1=array，该方式只是将
		//两个数组指向了同一个引用地址，实际在堆中只有一个数组对象
		String[] array1 = new String[array.length];
		for(int i = 0;i < array.length;i++)
			array1[i] = array[i];
		for(int i = 0;i < array1.length;i++)
			System.out.print(array1[i]+"\t");
		
		//数组的反转
		//方法一：
//		for(int i = array1.length - 1;i >= array1.length/2;i--){
//			String temp = array1[i];
//			array1[i] = array1[array1.length - i-1];
//			array1[array1.length - i-1] = temp;
//		}
		//方法二：推荐
		for(int j = 0,i = array1.length-1;j < i;j++,i--){
			String temp = array1[j];
			array1[j] = array1[i];
			array1[i] = temp;
		}
		System.out.println();
		for(int i = 0;i < array1.length;i++)
			System.out.print(array1[i]+"\t");	
	}
}

运行结果
aa bb CC dd EE
EE dd CC bb aa

• 数组元素的查找
• 线性查找

import java.util.*;
public class ArrayFindTest {
	public static void main(String[] args){
		String[] s = new String[]{"aa","1","bb","22","c"};
		//线性查找,很好理解，就是挨个查找
		String target;
		System.out.print("请输入要查找的元素:");
		Scanner scan = new Scanner(System.in);
		target = scan.next();
		scan.close();//关闭输入流资源，不关好像也没事，会警告Resource Leak资源泄露
		boolean notFound = true;
		for(int i = 0;i < s.length;i++){
			if(target.equals(s[i])){
				System.out.println("找到指定元素，位置为s"+"["+i+"]");
				notFound = false;
				break;
			}
		}
		if(notFound){
			System.out.println("未找到指定定元素");
		}
				
	}

运行结果
请输入要查找的元素:8
未找到指定定元素

请输入要查找的元素:bb
找到指定元素，位置为s[2]

• 二分法查找（前提为有序大小排列好的数组）

public class ArrayFindTest {
	public static void main(String[] args){

		//二分法查找，前提为有序数组（大小排列好的）
		int[]  arr = new int[]{-58,-42,3,3,3,8,57};
		int target1;
		boolean notFound = true;
		int head = 0,end = arr.length - 1;
		System.out.print("请输入要查找的元素:");
		Scanner scan = new Scanner(System.in);
		target1 = scan.nextInt();
		scan.close();
		while(head <= end){//为什么是 <= 呢？因为假设最后一步才找到，这
							//时head==end,需要再运行一次
			
			int middle = (head + end)/2;
			
			if(target1 == arr[middle]){
				System.out.println("元素以找到，位置为arr"+"["+middle+"]");
				notFound = false;
				break;
			}else if(arr[middle] < target1){
				head = middle + 1;
			}else{
				end = middle - 1;
			}
		}
		if(notFound){
			System.out.println("元素未找到");
		}
	}
}

运行结果
请输入要查找的元素:-42
元素以找到，位置为arr[1]

• 常用的数组工具类方法

import java.util.Arrays;//操作数组的工具类，里面定义了很多操作数据的方法

public class ArraysClassTest {
	public static void main(String[] args){
		
		//Arrays常用类
		
		//1.boolean equals(int s[],int b[])判断两个数组内容(包括顺序)是否相等
		int[] arr1 = new int[]{1,2,3,4,5};
		int[] arr2 = new int[]{1,5,2,4,3};
		boolean e = Arrays.equals(arr1,arr2);
		System.out.println(e);
		
		//2.Sring toString(int[] a):输出数组信息
		System.out.println(Arrays.toString(arr1));
		
		//3.void fill(int[] a,int value),将指定元素填满到数组中，数组元素全部变为指定值
		Arrays.fill(arr1,57);
		System.out.println(Arrays.toString(arr1));
		
		//4.void sort(int[] a);对数组进行 从小到大 排序
		Arrays.sort(arr2);
		System.out.println(Arrays.toString(arr2));
		
		//5.int binarySearch(int a[],int key);有序数组的二分查找，未找到元素时返回的是一个负数
		System.out.println("查找的元素位于["+Arrays.binarySearch(arr2,3)+"]");
		
		
		}

运行结果
false
[1, 2, 3, 4, 5]
[57, 57, 57, 57, 57]
[1, 2, 3, 4, 5]
查找的元素位于[2]

• 多维数组

public class ArrayTest2 {
	public static void main(String[] args){
		
		//一维数组
		int[] i = new int[]{1,2,3,4,5};
		System.out.println(i.length);
		//二维数组数组的遍历
		int[][] ii = new int[3][2];
		for(int x = 0;x < ii.length;x++){ //ii.length获取的是第一维长度
			for(int j = 0;j < ii[x].length;j++){ //ii[j].length获取的是第二维的长度
				System.out.print(ii[x][j]+"\t");
			}
		}
	}
}

运行结果
5
0 0 0 0 0 0

面向对象

• 权限修饰符(封装性)，对于局部变量不可以使用权限修饰符

private
public
缺省
protected

• 类的东西在内存中存储的位置

属性：加载到堆空间中 ，但static变量放在方法区中
局部变量：加载到栈空间

• 类中的方法
  方法：描述类的行为功能，方法中可以调用方法，但是方法中不可以定义另一个方法
  return语句后不可以有执行语句

• 快捷键

按住ctrl点击可跳转至方法详细位置，再按住Alt +←可返回，Alt + →可再次进入。

• 封装性

程序设计追求高内聚，低耦合
高内聚：类的内部数据操作细节自我实现，不需要外部干涉
低耦合：仅对外暴露少量的方法用于共享
隐藏对象内部的复杂性，只对外公开少量的接口，就想人一样，内部思想复杂，对外只有一个简历。追求对外信息的简便性，提高系统的可扩展性、可维护性，就像公司只关注职员的工作能力。该隐藏的隐藏，该暴露的暴露，这就是封装性的设计思想。JAVA封装性的实现，需要使用权限修饰符。

• 权限修饰符

• 四种权限（从小到大）

• private、缺省、protected、public（类内部》同一个包》不同包》同一个工程）
• 
  对于class的权限修饰符只能用public或default，public修饰的类的可以在任意地方访问，default修饰的类只能在同一个包内部的类访问。
• JavaBean

/*
*

• JavaBean,指符合以下标准的JAVA类
• 类是公共的；
• 有一个无参构造器
• 有属性，且有对应的set和get方法

*/