前面提到的,冒泡排序,二分查找,我们有时候写代码可能不止要查到一种数组的数据,这时候我们就很需要想循环那样的结构,来帮我们解决代码冗余的情况。
我们前面使用的main方法,是一个java程序的入口,我们可以把我们的冒泡排序、二分查找的方法的代码,写在方法里,不是方法套方法哦,这是不允许的。
1 定义方法
定义方法,可以这样分类:
1 、方法的( ) ,括号中如果有填入形参,就是 有参方法(形参) ,没有的话,就是 无参方法()
2、方法是否有返回值,且根据返回值的类型选择 如果是无返回值,就是void ,如果返回int,就用int,如果是有返回值类型的,切记要加上return。
下面来分析一下二分查找的这个代码
public class Test02 {
public static void main(String[] args) {
int[] array = new int[10000];
for (int i = 0; i < array.length; i++) {
array[i] = i;
}
//后半部分,是给二分查找方法传入主方法的数据,前半部分是,得到其返回值
//不然我们只调用了这个方法,就没有去得到我们想要的值,无论是没有找到的-1
//还是找到的那个值,就没有意义
int r = search(array,8888);
System.out.println(r);
}
//返回值类型为 int 类型 ,且是有参方法
public static int search(int[] arr, int a){
int start = 0;
int end = arr.length - 1;
while(start<=end){
int middle = (start + end)/2;
if (arr[middle] == a){
//如果要查找的这个数就是中间值,我们主方法中需要这个值,我们得返回
return middle;
}else if (a > arr[middle]){
start = middle + 1 ;
}else if (a < arr[middle]){
end = middle - 1 ;
}
}
//如果数组找不到这个值,就返回-1,以告诉程序员。
return -1;
}
}
2 引用数据类型——类
在java中只要创建了一个类,就是一个数据类型,类是一个模板,只有特征,没有具体数据
根据类在每个特征上输入对应的值,就会形成数据。
在java中 创建数据 需要用到关键词——new
//这个cat是对象,就是类中的一个实例
Cat cat = new Cat();
public void Cat(){
public String name ;
public int age ;
public String type ;
}
创建了特征后,需要对其进行赋值,如果不赋值,也会有默认值,默认值参考第四天的内容
cat.name = "胖熊";
cat.age = 1 ;
cat.type = "英短";
获取一条具体的数据
System.out.println(cat.name+cat.age+ "岁" +cat.type);
在给特征赋值的时候,有可能会涉及到一些判断,比如说,没有负岁数的对象,所以,对其特征赋值的时候,我们可以在类里的岁数的特征,对其进行判断
set方法进行赋值的时候,参数本来就是给属性复制的,赋值时候,变量名要加后缀,不能和属性重名,这里涉及一个局部变量与全局变量的重名问题
public void setAge(int age) {
if (age > 0){
this.age = age;
}else {
age = 0 ;
}
}
3 访问权限-修饰符
虽然我们对特征进行判断,但是在访问特征的时候,我们现在使用的方式是点访问,就还是可以随心所欲的将猫咪设成不可能是岁数。相对的,有另一种比较安全访问private,这种修饰符下的特征则需要通过特殊的方式进行访问,就不会随便接受不合理的赋值了
public class Cat {
private String name;
private int age;
private String type;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age > 0){
this.age = age;
}else {
age = 0 ;
}
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
}
public class Test01 {
public static void main(String[] args) {
Cat cat = new Cat();
cat.setName("胖熊");
cat.setAge(1);
cat.setType("英短 纯白");
System.out.println(cat.getName()+cat.getAge()+ "岁" +cat.getType());
}
}
private修饰的特征叫属性,属性私有化,给私有属性赋值和取值的方式就是 set get
不知不觉中,我们就把封装给诠释了出来,封装就是一个保护罩,保护代码和数据,避免被外部类定义的代码随便访问,要访问该类的代码和数据,必须通过严格的接口控制,封装的最主要的功能就在于 ,我们能修改自己的实现代码,而不用修改那些调用了这些代码的程序
适当的封装,加强了程序的安全性。
4 全局变量与局部变量
如果写在类中特征的属性的作用范围就是当前类——全局变量 类中定义
如果变量在方法内定义或者方法参数上定义 作用范围就是当前方法——局部变量 方法中定义
局部变量距离使用的变量近
全局变量距离使用的变量远
局部变量是方法中的一个参数
全局变量是类中的一个属性
this关键字区别局部变量和全局变量 this.当前变量=值
在我们的案例中,现在使用的是哪个对象 this就是谁 ,谁现在调用了set方法 this就是谁
public void setAge(int age) {
if (age > 0){
this.age = age;
}else {
age = 0 ;
}
//类中的当前对象
System.out.println(this);
}
public static void main(String[] args) {
Cat cat = new Cat();
cat.setName("胖熊");
cat.setAge(1);
cat.setType("英短 纯白");
//System.out.println(cat.getName()+cat.getAge()+ "岁" +cat.getType());
System.out.println(cat);
Cat cat1 = new Cat();
cat1.setAge(1);
System.out.println(cat1);
}
输出:
Demo.Cat@1b6d3586
Demo.Cat@1b6d3586
Demo.Cat@4554617c
Demo.Cat@4554617c
5 toString
在上面的代码中,我们获取一个对象的全部数据的时候,我们会自己拼接起来,实际上在java中,有一个toString方法,在对象被打印的时候,会被默认调用。
@Override
public String toString() {
return "Cat{" +
"name='" + name + '\'' +
", age=" + age +
", type='" + type + '\'' +
'}';
}
public class Test01 {
public static void main(String[] args) {
Cat cat = new Cat();
cat.setName("胖熊");
cat.setAge(1);
cat.setType("英短 纯白");
System.out.println(cat);
}
}
输出:
Cat{name='胖熊', age=1, type='英短 纯白'}
6 构造方法
只要我们创造了类,在类中就会有一个默认的无参构造方法,这个构造方法就是为了给我们进行对象的创建
public Cat() {
}
只要我们自己写了构造方法,其默认的构造方法就会失效。
现在写一个带参的构造方法,有了这个构造方法,创建对象的时候,就会指引我们如何创建,我们就按照格式创造就可以,边创造边赋值。
//带参构造方法
public Cat(String name, int age, String type) {
this.name = name;
this.age = age;
this.type = type;
}
Cat cat = new Cat("胖熊",1,"英短 纯白");
7 方法重载
一个类中不能有两个相同的方法,但是我们在创造对象的时候,不想要它因为我们的有参构造方法的存在而报错,可以使用方法重载
在一个类中,方法名相同,参数列表不同 就是方法重载
参数列表不同可以是以下表现:
1、参数的个数不同 无参 有参
2、参数的顺序不同 String int int String
3、参数的类型不同 int String