Java入门（二）

面向对象&方法&选择排序

#20190730

一、面向对象

1.概念

面向对象程序设计（OOP），是一种基本对象概念的软件开发模式
特征：封装、继承、多态

2.对象

对象的特征：状态，即本身具有的属性

行为，即对象具有的功能
对象是具体的
对象是类的实例化

3.类

类是具有相同的状态和行为的一组对象的集合。
类的属性就是对象的状态，类的方法就是对象的行为。
要创建对象必须先定义类，通过实例化来创建对象。
类是抽象的
类是对象的模板，对象的类具体实例

4.类的定义

类的构成

面向对象设计就是抽象的过程，也就是设计类的过程。
类的定义分为三步：
1. 发现类，类定义了对象将会拥有的属性(特性)和方法（行为）
2. 发现类的属性，对象的特性在类中称为类的属性
3. 发现类的方法，对象执行的操作在类中称为类的方法

格式：

[访问修饰符] class 类名{

    成员变量声明; //属性

    成员方法声明; //行为

}

例子

public class Person {
//	定义类的属性
	public String name;
	String gender;
	int age;
    
//	定义类的方法
	public void study() {
		System.out.println("good good study,day day up!");
	}
	public void work() {
		System.out.println(name+"会赚钱");
	}
}

5.创建对象

类的对象可以调用类的成员，成员方法，成员属性。

创建对象的格式:

类名对象名 = new 类名();

new关键字，主要是实例化对象

等号右边的类名()是这个类的构造方法

Person zhangsan = new Person();

6.使用对象

//在主方法里：
	public static void main(String[] args) {
//		创建对象
		Person zs=new Person();
		zs.name="张三";	//通过(对象名.属性/方法名())调用
		zs.age=29;		
		zs.gender="男";
		
		Person ls=new Person();
		ls.name="李四";
		ls.age=24;
		ls.gender="男";
		
		Person wer=new Person();
		wer.name="王二麻子";
		wer.gender="保密";
		wer.age=18;
    }

7.对象数组

//		对象数组
		Person[] pers=new Person[3];
		pers[0]=zs;//不是给数组赋值，zs是前面new的对象
		pers[1]=ls;
		pers[2]=wer;
//		输出对象数组
		for(int i=0;i<3;i++) {
System.out.print(pers[i].name+","+pers[i].gender+","+pers[i].age+"\n");
        }//不是直接输出数组，要数组名[].属性

二、方法重载

1.定义

方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数类型或参数个数或参数顺序
- 参数顺序不同是针对类型不同的参数而言，相同数据类型的两个参数不行，因为都是形参。

2.方法重载的特点

在同一个类中
方法名相同，参数类型/个数/顺序不同
方法的返回值不能作为方法是否重载的依据

3.方法重载的调用

按照方法参数的类型，个数和顺序依次传参调用
例子：

//	方法重载(写在主方法外)
	public void work(String item) {
		System.out.println("the best workmen is "+this.name+item);
	}
	public void study(int ratio) {
		System.out.println(this.name+"的学习效率值是"+ratio+"%");
	}
	public void study(String sname,int number) {
		System.out.println(this.name+"是"+sname+"的第"+number+"个学生");
	}
	public static void main(String[] args) {
//		主方法里调用其他方法
		zs.study();
		zs.work();
//		通过参数类型或个数判断要调用哪个重载方法
		ls.work("程序员");
		wer.study(75);
		wer.study("云创动力",100);
	}

4.方法重载的优点

重载根据传参的不同，可以调用不同的方法实现，不需要写定义多个不同的名称，简化了调用

三、方法

1.概念

方法是完成特定功能、相对独立的代码段。与其他程序语言中的子程序、函数等概念相当。
方法定义完成后，可以多次调用，提高开发效率。
方法的标志 '()'

2.定义方法

格式：
```
[修饰符] 返回值类型 方法名([参数列表]){

	//方法体

}
```
- 解析：
  1. [修饰符]：是可选项，可以是访问修饰符（public、private、protect），也可是其他。
  2. 返回值类型：可以是void（无返回类型）,也可以是其他（int、String等），其他则需要至少一个相同数据类型的返回值；return是结束当前方法，返回到方法的调用处，调用处可以用变量接收返回值，也可直接输出。
  3. 方法名()：方法名要符合标识符命名规则，不能与关键字重名；
  4. [参数列表]：指定在调用该方法时，应该传递的参数的个数和数据类型，可以没有参数，也可以有多个参数（用“,”隔开）.
  5. 但是不能嵌套。
- static修饰符，表示静态，可以用类名.方法来调用；否则调用成员方法要new一个对象，用对象名.方法调用。

3.成员变量

定义在类的内部，方法外面的变量，叫做成员变量。
成员变量可以在定义的时候初始化，也可以在使用的时候初始化。

4.局部变量

定义在方法里面的变量，称为局部变量

5.成员变量及局部变量的区别

	成员变量	局部变量
作用域	作用域在整个类中，包括所有的成员方法都可以使用。如果访问权限允许类的外部也可使用	作用域仅在方法内部
初始化	如果不初始化，java会根据数据类型自动给默认值	如果使用前不初始化，编译会报错
变量名	在同一个类里不能有同名的成员变量	在不同的方法内，允许出现同名的局部变量

补充：局部变量可以和成员变量同名，使用的时候局部变量优先。

成员变量在方法里用 this.变量名调用；直接用变量名是方法里的变量。

6.方法的调用

发出调用的方法为主方法，被调用的是被调方法。
例子：

public class Person {
//	定义类的方法
	public static void study() {
		System.out.println("good good study,day day up!");
	}
//在主方法里：
	public static void main(String[] args) {
//		主方法里调用其他方法
		study();//和Person.study();一样
		}
}

7.数据类型（值传递和引用传递）

基本数据类型有八种（byte short char int long float double boolean）,引用数据类型有三种（类、数组、接口）
基本数据类型间赋值是值传递，引用数据类型是传地址，叫引用传递；

例子：

public class Cla2 {
// 定义一个成员变量
	public int variable;
}

public class Cla1 {
//对比方法内部对基本数据类型参数与引用类型参数重新赋值后对主调方法的影响。
	public static void main(String[] args) {
		//对基本数据类型参数重新赋值的过程和结果
		System.out.println("基本数据类型");
		char num1='一';
		char num2=num1;
		System.out.println("修改前："+num1+"\t"+num2);
		num2='改';
		System.out.println("修改后:"+num1+"\t"+num2);
		//对引用类型参数重新赋值的过程和结果（引用Cla2）
		System.out.println("引用类型参数");
		Cla2 obj=new Cla2();//引用Cla2创建一个对象
		obj.variable=11;	//给对象赋值
		Cla2 obj2=obj;		//把前一个对象的地址赋值给新的对象
		System.out.println("改变前："+obj.variable+","+obj2.variable);
		obj2.variable=22;	//改变新对象成员变量的值
		System.out.println("改变后："+obj.variable+","+obj2.variable);	
	}
}

输出：

基本数据类型：修改前：一一修改后：一改

引用类型参数：改变前：11,11 改变后：22,22

四、选择排序

1. 原理

工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

2. 描述

n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：

初始状态：无序区为R[1..n]，有序区为空；
第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
n-1趟结束，数组有序化了。

3. 动图演示

4. 代码

/**
* 选择排序
* @param its 待排序的数组
* @return 排序完成后的数组
*/
public static void selectionSort(int[] its) {
    //如果数组里数值数量少于2个，就不用排序
    if (its.length < 2) return ;
    //有序区  i = n  
    for (int i = 0; i < its.length -1 ; i++) {
        //无序区
        int min = i;
        for (int j = i + 1; j < its.length; j++) {
            //找最小值
            if (its[min] > its[j]) {
           	 min = j;
            }
        }
        //交换位置
        int temp = its[i];
        its[i] = its[min];
        its[min] = temp;
    }
}

5.特点

表现最稳定的排序算法之一，因为无论什么数据进去都是O(n2)的时间复杂度，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间。

6.与冒泡相比

冒泡是相邻两个数比较大小，然后交换；而选择是取从第一个数开始的数，与所有剩下的数比较，取最小值与之交换。这样交换了几轮就确定了几个数，最后一个数没有交换对象，不用交换。

心得体会

今天的内容很多...好像每天都很多哦......但是因为之前学过，所以记的也没那么吃力，总的来说没什么问题。突然发现我心得越写越少了，没别人有才华，哈哈哈。

构造方法 & 可变参 & this

#20190731

一、构造方法

1.作用

成员变量的初始化

2.格式

[访问修饰符] 方法名/类名([参数列表]){
    //方法体
}

解析：
- 构造方法没有返回值
- 默认构造方法没参数
- 构造方法的方法名必须与类名相同
如果自定义了构造方法，那么java就不会提供默认构造方法
构造方法分为默认构造和自定义构造

二、变量作用域和生命周期

成员变量的作用域是整个类
生命周期是变量从开始到消亡的过程，java中有回收处理机制

三、可变参

1.格式

数据类型...变量名

表示可以不传参数，也可以传多个参数，参数数量不固定
可变参必须是参数列表的最后一个，并且一个方法只能有一个可变参

四、扩展

1.递归

简单来说，递归就是方法自己调用自己。和循环比较像，都需要一个边界来结束

/**
	 * 递归实现斐波那契
	 * @param a
	 * @param b
	 */
	public static void fbnq1(int a,int b) {
		if(a+b > 100) return;  //递归边界，来结束调用
		System.out.println(a + b);
		fbnq1(b,a+b);
	}

/**
	 * for循环实现斐波那契数列
	 */
	public static void fbnq() {  // 1 2 3 5 8 13 21
		int a = 1,b=0,c = 0;
		for (int i = 0; i < 10; i++) {
			c = a + b;  // 输出的斐波那契数
			//数列后移(交换位置)
			a = b; 
			b = c;
			System.out.println(c);
		}
	}

2.静态变量/方法

凡是被static关键字修饰的变量都是静态变量，也叫类变量。
static修饰的方法叫静态方法，也叫类方法。

	静态变量/方法	成员变量/方法
所有者	当前类	类的对象（实例）
调用	静态方法之间可以相互调用	成员方法间可直接调用
使用	一个类的静态方法可以直接调用当前类的静态变量	成员方法里用对象.成员变量名调用成员变量

3.this

this关键字是对一个对象的默认引用（哪个对象调用，就是指那个对象）
每个实例方法中都有一个this，指向的是调用该方法的对象
this可以调用成员方法，成员变量，构造方法。在调用构造方法时，必须是代码段的第一句
this不能调用局部变量

使用：

调用成员变量，解决成员变量与局部变量的同名冲突

public class Person{
	public String name;
	public void setName(String name){
	//成员变量与局部变量同名，this.name表示成员变量，name表示局部变量
	this.name = name;
	}
}

public class Person{
	public String name;
	public void setName(String str){
	//成员变量与局部变量同名，this可以省略
	name = str;
	}
}

使用this调用成员方法
使用this调用重载的构造方法，只能在构造方法中使用，且必须是构造方法的第一条语句

4.标签

标签适用于循环
例子：

/**
* 随机输出30个，40以内不重复的数
*/
int[] nums = new int[30];
outer: for (int i = 0; i < 30; i++) {
    Random rand = new Random();
    int num = rand.nextInt(40);
    inner: for (int j = 0; j < nums.length; j++) {
        if (num == nums[j]) {
        //如果有重复，重新给当前位置赋值
        i--;
        //结束外层for的本次循环
        continue outer;
        }
    }
    nums[i] = num;
    }
    Arrays.sort(nums);
    System.out.println(Arrays.toString(nums));
}

outer:和 inner:都是标签，自定义的
[Java 循环中标签的作用]

五、课后作业

编写两个方法实现两个数的加和乘，返回计算的结果，并且用键盘任意输入两个数对四个方法进行调用。

//p82 01
public class HomeWork {
//	成员方法
	//加减法
	public static int add(int num1,int num2) {
		return num1+num2;
	}
	public static int sub(int num1,int num2) {
		return num1-num2;
	}
	//乘除法
	public static int mul(int num1,int num2) {
		return num1*num2;
	}
	public static double div(int num1,int num2) {
		double rel=0;
		if(num2<=0) {
			System.out.println("除数不能为0");
		}else {
			rel=num1/num2;
			System.out.println(num1+"/"+num2+"="+rel);
//			prl(num1,"/",num2,rel);
		}
		return rel;
	}
	
	//输出
	public void prl(int num1,String flag,int num2,double sum) {
		System.out.println(num1+flag+num2+"="+sum);
	}
//	主方法
	public static void main(String[] args) {
		int a,b;
		double sum=0;
//		键盘输入
		Scanner sc=new Scanner(System.in);
		System.out.println("请输入第一个数:");
		a=sc.nextInt();
		System.out.println("请输入第二个数:");
		b=sc.nextInt();
		System.out.println("请选择所做运算：");
		String flag=sc.next();
//		主要过程
		if("+".equals(flag)) {
			sum=add(a,b);
		}else if("-".equals(flag)) {
			sum=sub(a,b);
		}else if("*".equals(flag)) {
			sum=mul(a,b);
		}else if("/".equals(flag)){
				div(a,b);
				return;
		}else {
			System.out.println("用户输入有误！");
			return;
		}
//		输出
		HomeWork hw=new HomeWork();
		hw.prl(a,flag,b,sum);
//		prl(a,flag,b,sum);
		
	}

}

定义一个方法，实现从输入的两个参数中返回大的数

public class HomeWork2 {
//	P82 02
    //判断两个数大小
	public static int Max(int num1,int num2){
		int max=num1>num2?num1:num2;
		return max;
	}
    //输出
	public static void main(String[] args) {
		//从键盘输入
		Scanner sc=new Scanner(System.in);
		System.out.println("第一个数是：");
		int a=sc.nextInt();
		System.out.println("第二个数是：");
		int b=sc.nextInt();
		//输出结果
		int max=Max(a,b);
		System.out.println("最大数为："+max);
	}	
}

心得体会

今天很有成就感，因为写完了好几题，确实也有几题挺纠结的，比如说春晓……

包 & 访问修饰符 & staic & 封装

#20190801

一、包

1. 作用：

存放类：易于找到和使用相应的类文件
防止命名冲突：Java中只有在不同的包中的类才能重名。
包允许在更广的范围内保护类、数据和方法。根据访问规则，包外的代码有可能就访问不到

2.语法格式

package 包名

3.命名规范：

一个唯一的包名前缀通常是全部小写的ASCII字母，并且是一个顶级域名com、edu、gov、net及org，通常使用域名的倒叙。例如：公司域名为 www.gongsi.com ,则包名为 com.gongsi.
包名的后续部分一般为部门或功能或项目来命名

4.实例

建立多个包后，包的结构

5.windows下使用命令编译执行java代码步骤（带包名）：

代码如下：

package day4.pack.test.b1;

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

首先进入命令提示窗口并进入到java文件存放目录
使用javac -d <目录> 命令编译java类
最后使用java 包路径.类名执行java代码
例子：

二、访问修饰符

java中访问修饰符有4种，分别是public、protected、默认（缺省）、private。

1.类的访问修饰符

修饰符\作用域	同一包中	不同包中
public	√	√
默认（缺省）	√	×

2.类成员的访问修饰符

位置	public	protected	默认(缺省)	private
同类中	√	√	√	√
同包其他类	√	√	√	×
同包子类	√	√	√	×
不同包子类	√	√	×	×
不同包非子类	√	×	×	×

访问修饰符不能修饰方法中的变量（局部参数）和形式参数，因为它们的作用域仅限于该方法内部

三、static

1.static修饰属性

用static修饰的属性称为静态属性或变量
属于类不属于对象
用类名. 调用就行

2.static修饰方法

static修饰的方法称为静态方法或者类方法
不用static修饰的方法称为实例方法
静态方法不能直接访问实例变量和实例方法
在实例方法中可以直接调用类中定义的静态变量和静态方法

3.静态与实例的区别

JVM内存分区：方法区、堆区、栈区、静态区、常量区
所以，静态与实例的区别是什么？
- 实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

四、封装

1.什么是封装

封装是面向对象三大特征之一
封装是将类的状态信息（成员变量）隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法进行访问。

2.封装的好处

封装反映了事务相对的独立性，有效避免了外部错误对此对象的影响，并且能对对象使用者由于大意产生的错误操作起到预防作用。同样面向对象编程提倡对象之间实现松耦合关系。
封装好处在于隐藏类的实现细节，让使用者只能通过开发者规定的方法来访问数据，可以方便的加入存取控制修饰符，来限制不合理的操作。

五.数据类型（值传递和引用传递）

基本数据类型有八种（byte short char int long float double boolean）,引用数据类型有三种（类、数组、接口）
基本数据类型间赋值是值传递，引用数据类型是传地址，叫引用传递；

例子：

public class Cla2 {
// 定义一个成员变量
	public int variable;
}

public class Cla1 {
//对比方法内部对基本数据类型参数与引用类型参数重新赋值后对主调方法的影响。
	public static void main(String[] args) {
		//对基本数据类型参数重新赋值的过程和结果
		System.out.println("基本数据类型");
		char num1='一';
		char num2=num1;
		System.out.println("修改前："+num1+"\t"+num2);
		num2='改';
		System.out.println("修改后:"+num1+"\t"+num2);
		//对引用类型参数重新赋值的过程和结果（引用Cla2）
		System.out.println("引用类型参数");
		Cla2 obj=new Cla2();//引用Cla2创建一个对象
		obj.variable=11;	//给对象赋值
		Cla2 obj2=obj;		//把前一个对象的地址赋值给新的对象
		System.out.println("改变前："+obj.variable+","+obj2.variable);
		obj2.variable=22;	//改变新对象成员变量的值
		System.out.println("改变后："+obj.variable+","+obj2.variable);	
	}
}

输出：

基本数据类型：修改前：一一修改后：一改

引用类型参数：改变前：11,11 改变后：22,22

心得体会

this. 是用在哪里，今天在主方法里用成员变量的时候用了this. 报错，用对象名. 对了；所以是不是this.只在构造方法里使用。静态方法里没有this，所以在主方法里不能用this

下面这段代码不知道错哪了：

	public static void main(String[] args) {
		Person ren = new Person();
		Person kangkang = new Person();
		kangkang.name = "kangkang";
		kangkang.gender = "男";
		kangkang.age = 23;
		kangkang.married = false;
		
		ren.marry(kangkang);
    }

//		判断是否满足结婚条件
	public void marry( Person another ) {
		if(married) {
			System.out.println("已婚人士离婚前不能二婚");
			return;
		} else {
			if("男".equals(gender)) {		// 这里调用完直接跳到了 A 处
				if(age < 22) {
					System.out.println("您未到法定结婚年龄");
				}else{
					System.out.println("您可以结婚");
				}
			}else{
					if(age < 20) {			// A
						System.out.println("您未到法定结婚年龄");
					}else{
						System.out.println("您可以结婚");
					}
			}
		}
    }

静态变量方法 & 返回值 & 字符串字面量

#20190802

1.静态变量/方法与成员变量/方法的区别

静态变量和静态方法的所有者都是当前类

成员变量和成员方法的所有者是类的对象（实例），成员方法间可直接调用

一个类的静态方法可以直接调用当前类的静态变量，静态方法之间可以相互调用

2. 构造方法

要创建一个类的对象时，需要实例化这个类，通常是调用该类的构造方法（new 构造方法()）来实例化.

构造方法：

方法名与类名相同
没有返回值（不是void）
java默认的构造方法是无参构造（没有参数）
如果自定义了构造方法，那么java就不会提供默认无参构造方法
```
[访问修饰符] 方法名(类名){

	//方法体;

}
```

如果没有无参构造方法，就不能使用new 类名();来实例化对象
构造方法不是一定要初始化变量的。

3. this

this关键字是对一个对象的默认引用（哪个对象来调用，就是哪个对象。只有在程序运行时才知道this具体指哪个对象）

每个实例方法中都有一个this，指向的是调用该方法的对象

this可以调用成员方法，成员变量，构造方法。在调用构造方法时，必须是代码段的第一句

this不能调用局部变量

this可以调用静态方法，静态变量。但不推荐这样做；

同一个类的this相同

4. 方法调用

3.1 同一个类中成员方法调用成员方法，直接调用

3.2 静态方法中调用成员方法，创建被调用方法所在类的实例

3.3 成员方法调用静态方法，在可访问的情况下，类名.方法直接调用。

	两个方法在同一个类中，可以省略类名。即直接调用

3.4 静态方法调用静态方法，在可访问的情况下，类名.方法直接调用。

	两个方法在同一个类中，可以省略类名。即直接调用

3.5 静态方法可以被类对象调用，但不推荐这样做

5. 返回值

首先注意，方法头上声明的返回值类型必须与return后面的返回值类型一致。

如果方法有返回值，在方法的调用处可以使用相同类型的变量接收返回值。

如果没有返回值

6.字符与字符串

字符类型（char）：是用’ ‘引住的单个符号，用“ ”引住的是字符串
例子：随机密码

package pack;

import java.util.Random;

public class StringDemo {
	// 成员变量
	Random rm = new Random();

	public static void main(String[] args) {
		StringDemo s = new StringDemo();
		String pass = s.randomPass();
		System.out.println(pass);

	}

	/**
	 * 生成随机密码： 随机生成9位有大小写字母、数字组成的密码 ASCII码
	 */
	public String randomPass() {
		String password = "";
		for (int j = 0; j < 3; j++) {
			password += randomU();
			password += randomL();
			password += randomN();
		}
		return password;
	}

	/**
	 * 生成大写字母
	 * 
	 * @return
	 */
	public char randomU() {
		// 大写字母
		/**
		 * (char) (rm.nextInt(26) + 65) 等同于 int i = rm.nextInt(26) + 65; char a = (char)
		 * i;
		 */
		return (char) (rm.nextInt(26) + 65);
	}

	public char randomL() {
		// 小写字母
		/**
		 * 小写 int i1 = rm.nextInt(26); i1 += 97;
		 */
		return (char) (rm.nextInt(26) + 97);
	}

	public int randomN() {
		// 生成数字
		return rm.nextInt(10);
	}

}

7.字符串对象与字面量

字面量：String 变量名 = “初始值”；
字对象：String 变量名 = new String（“初始值”）；
**基本数据类型转String类型:**String s =String.VlaueOf(i);

心得体会

晚上装了一晚上系统，装完好不习惯，但是心理上感觉电脑干净了很多。然后，一晚上没有敲代码有了点生疏感 /狗头

字符串对象和字面量 & 常用方法

#20190805

一、字符对象和字面量

1. 字符串声明（两种方式）

字符串对象：String str = new String("初始值");//有参构造函数
字面量：String str1 ="abc";
内存图

例子：

//		字符串对象
		String str = new String("123");//有参构造函数
		System.out.println(str);
//		字变量
		String str1 = "123";
		System.out.println(str1);

二、常用方法

//	"=="比较两者地址是否相等
		System.out.println("比较两个字符串(地址)是否相等："+ (str1 == str));

//	"equals()"比较两个字符串是否相等
		System.out.println("比较两个字符串(内容)是否相等"+ str.equals(str1));

//	"equalsIgnoreCase(String)"忽略大小写比较两个字符串是否相等
		System.out.println("忽略大小写比较两个字符串（数字）是否相等:"+str.equalsIgnoreCase(str1));
		String t1 = "ABCdb";
		String t2 = "aBcDc";
		System.out.println("忽略大小写比较两个字符串（字母）是否相等:"+t1.equalsIgnoreCase(t2));

在输出中直接用“==”且前面有”+“的时候要记得加”()“；
当内容相等但是开辟的空间不同的时候，“==”会返回false；

//	"字符串对象名.length()"获取字符串长度
		System.out.println("获取字符串(str)长度:" + str.length());//这里length是一个方法，而不是变量；
//	"数组对象名.length"获取数组长度
		int[] arr = new int[]{1,2,4,1};
		int i=arr.length;//这里length是数组类的成员变量（属性）；
		System.out.println("数组arr的长度:" + i);

注意:字符串中的length是方法，而数组中的length是成员变量

//		获取字符串中的一个字符
		System.out.println("获取字符串中某一个字符："+ t1.charAt(2)); //这里2是t1的下标
//		传入字符串在原字符串中 第一次 出现的位置
		System.out.println("传入字符串d在原字符串t1中第一次出现的位置:" + t1.indexOf("d"));
//		传入字符串在原字符串中最后一次 出现的位置
		System.out.println("传入字符串在原字符串中最后一次 出现的位置：" + t2.lastIndexOf("c"));
//		原字符串是否以传入字符开头/结尾
		System.out.println("原字符串是否以传入字符开头：" + t2.startsWith(t1));
		System.out.println("原字符串是否以传入字符结尾：" + t2.endsWith("c"));

"charAt(int)"获取字符串中的一个字符,这里int是数组下标

//		判断两个字符串大小
		String s1 = "HANYAN";
		String s2 = "hanyan";
		System.out.println("判断两个字符串大小：" + s1.compareTo(s2));
		
//		获取小写字符串
		System.out.println("获取小写字符串：" + s1.toLowerCase());
		System.out.println("获取大写字符串："+ s2.toUpperCase());

str.compareTo(String another) 按字典顺序比较两个字符串:
- 取str和another长度的最小值 min
- 则.循环判断两个字符串从第0位到min之间字符大小（Unicode）
- 如果当前索引处的字符相等，则进行下一位的判断
- 如果不相等，返回(char)str[index] - (char)another[index];
- 如果每一位都相等，返回str.length() - another.length();

//		从传入参数位置开始截取字符串到结束/指定位置
		String str5 = "da zao IT te zhong bing";
		System.out.println("从传入参数位置开始截取字符串到结束：" + str5.substring(7));
		System.out.println("从传入参数位置开始截取字符串到（参数2-1）：" + str5.substring(7,12));
		
//		将原字符串按照传入参数分割为字符串数组
		String[] sts = str5.split(" ");
		System.out.println("数组长度：" + sts.length);
		for (int j = 0; j < sts.length; j++) {
			System.out.print(sts[j]+",");
		}

通过split()方法返回的是一个字符串数组，不是字符串，其实参数为“”时就能实现字符串转字符数组
用**toCharArray()**可以实现字符串转字符（char）类型数组

//		基本数据类型转字符串类型
		int a = 10;
		byte b = 1;
		char c = 'a';
		long lo = 10L;
		double db = 10.0;
		float f = 10f;
		boolean ff = true;
		short ss = 11;
		System.out.println(String.valueOf(a));
		System.out.println(String.valueOf(b));
		System.out.println(String.valueOf(c));
		System.out.println(String.valueOf(lo));
		System.out.println(String.valueOf(db));
		System.out.println(String.valueOf(f));
		System.out.println(String.valueOf(ff));
		System.out.println(String.valueOf(ss));

当用valueOf()输出对象时，结果是完整的包名+类名+对象地址

心得体会

今天介绍的方法很多，每个方法的作用和功能也都了解，但是在做课后作业时发现，综合运用起来并不是那么快，需要慢慢积累练习，才能熟练，也才比较不容易忘。

字符串知识点补充

1、补充：

contains(CharSequence s) 当且仅当此字符串包含指定的char值序列时才返回true。
**matches(String regex)**根据regex表达式匹配，如果匹配返回true，否则返回false。
String内存地址分配

String str = "Hello";
String str2 = "World";
String str3 = "HelloWorld";
String str4 ="Hello" + "World";
System.out.println(str3.equals(str4));
System.out.println(str3 == str4);

输出：true;

true;

2、字符“ ”输出

在system.out.println("");中输出字符“ ”，要用"

3、字符串定义

String str = "abc";

相当于：

char data[] = {'a', 'b', 'c'}; String str = new String(data);

4、习题

给定一个只包括 '('，')' 的字符串，判断字符串是否有效。

public boolean isValid(){
    //需要判断的数组
		String str = "()))";
    //用来判断的数组
		String str1 = str;
		for(int i = 0; i < str.length()/2;i++) {
			str1 = str1.replace("()","");
		}
    //上面替换完后剩下的内容里是否包含"("或")"
		if(str1.length()==0) {
			return true;
		}else {
            //字符串转数组，用ASCII码判断
			char[] str2 = str1.toCharArray();
			for(int i=0;i<str2.length;i++) {
				if((int)str2[i]==40||(int)str2[i]==41) {
					return false;
				}
			}
			return true;
		}
	}
//主方法里调用
	public static void main(String[] args) {
		Bracket b = new Bracket();
		boolean flag = b.isValid();
		System.out.println(flag);
	}

输出：false

附加题：如果是包含三种括号的呢? () [] {}

public boolean isValid(){
		String str = "{{}(())[]}";
		String str1 = str;
    //每次循环把一对对的括号替换掉
		for(int i = 0; i < str.length()/2;i++) {
			str1 = str1.replace("()","");
			str1 = str1.replace("{}","");
			str1 = str1.replace("[]","");
		}
    //替换完数组长=0，则为true
		if(str1.length()==0) {
			return true;
		}else {
			char[] str2 = str1.toCharArray();
			for(int i=0;i<str2.length;i++) {
				int b1=(int)str2[i];
				int b2=(int)str2[i];
				int b3=(int)str2[i];
				//用ASCII码判断是否还剩下括号
				if(b1==40||b1==41||b2 == 123||b2 == 125||b3==91||b3==93) {
					return false;
				}
			}
			return true;
		}
	}
	
	public static void main(String[] args) {
		ValidBracket b = new ValidBracket();
		boolean flag = b.isValid();
		System.out.println(flag);
	}

输出：true

心得体会

今天不知道日志怎么写，偷个懒把题放上去。

Java学习日记（二）

Java入门（二）

面向对象&方法&选择排序

一、面向对象

1.概念

2.对象

3.类

4.类的定义

5.创建对象

6.使用对象

7.对象数组

二、方法重载

1.定义

2.方法重载的特点

3.方法重载的调用

4.方法重载的优点

三、方法

1.概念

2.定义方法

3.成员变量

4.局部变量

5.成员变量及局部变量的区别

6.方法的调用

7.数据类型（值传递和引用传递）

四、选择排序

1. 原理

2. 描述

3. 动图演示

4. 代码

5.特点

6.与冒泡相比

心得体会

构造方法 & 可变参 & this

一、构造方法

1.作用

2.格式

二、变量作用域和生命周期

三、可变参

1.格式

四、扩展

1.递归

2.静态变量/方法

3.this

4.标签

五、课后作业

心得体会

包 & 访问修饰符 & staic & 封装

一、包

1. 作用：

2.语法格式

3.命名规范：

4.实例

5.windows下使用命令编译执行java代码步骤（带包名）：

二、访问修饰符

1.类的访问修饰符

2.类成员的访问修饰符

三、static

1.static修饰属性

2.static修饰方法

3.静态与实例的区别

四、封装

1.什么是封装

2.封装的好处

五.数据类型（值传递和引用传递）

心得体会

静态变量方法 & 返回值 & 字符串字面量

1.静态变量/方法与成员变量/方法的区别

2. 构造方法

3. this

4. 方法调用

5. 返回值

6.字符与字符串

7.字符串对象与字面量

心得体会

字符串对象和字面量 & 常用方法

一、字符对象和字面量

1. 字符串声明（两种方式）

二、常用方法

心得体会

字符串知识点补充