自动化测试-java基础知识05

最新推荐文章于 2024-04-09 09:33:09 发布

一个正经的测试

最新推荐文章于 2024-04-09 09:33:09 发布

阅读量209

点赞数 1

分类专栏：移动端测试 appium 软件测试必备之Java基础文章标签： java 算法 appuim

本文链接：https://blog.csdn.net/gerouhsius/article/details/127176805

版权

移动端测试同时被 3 个专栏收录

7 篇文章 1 订阅

订阅专栏

软件测试必备之Java基础

6 篇文章 0 订阅

订阅专栏

appium

5 篇文章 0 订阅

订阅专栏

自动化测试-java基础知识05

1、方法的定义

作用：节省重复代码编写
格式：修饰符返回值方法名（参数列表）
{
方法体；
}
例子
public void show()
{
System.out.println(“show”);
}
方法代码示例

public class HelloWord {

	public static void main(String[] args) {
     //自定义方法
	int[] arr = {1,2,3,4};
	//遍历
	for(int i=1;i<arr.length;i++) {
		System.out.println(arr[i]);
	}
	print(arr);
	System.out.println("-----华丽的分界线-----");
	//第二个遍历
	int [] arr2 = {5,6,7,8,9};
	for(int i=1;i<arr.length;i++) {
		System.out.println(arr2[i]);
	}
}
	public static void print(int[] arr) {
		for(int i=0;i<arr.length;i++) {
			System.out.println(arr[i]);
		}
	}


}

2、方法重载

重载：在同一个类中出现了方法名相同，参数列表不同的方法时，我们称之为方法的重载
例如
public int add(int a,int b)
{
return a+b;
}
public double add(double a,double b)
{
return a+b;
}

public class HelloWord {

	public static void main(String[] args) {
   //方法重载	
	int a=10;
    int b=5;
    int sum1 = add(a,b);
    System.out.println(sum1);
    double c = 1.0;
    double d = 3.1;
    double sum2 = add(c,d);
    System.out.println(sum2);
}
	public static int add(int a,int b)
	{ 
	  return a+b;
	}
	
	public static double add(double a,double b)
	{
	  return a+b;
	 }
}

3、面向对象和面向过程

面向对象：把事情交给对象去完成，比如我们想吃饭，我们可以点外卖，直接利用美团app直接下单，然后付款，等半个小时，外卖就到家了
面向过程：所有的事情，都是自己去完成，比如，你想吃饭，你得出门，买菜，洗菜，做菜，然后才能吃饭，这就是面向过程

4、类与对象

类：模板，一类事物，静态的是属性。动态的是方法
比如：学生，姓名，年龄是属性，学习，睡觉，打游戏，是方法
对象：对象是类的具体实现，比如学生张三，李四，就属于，学生类里面的对象

5、定义一个学生类


//一个学生类
public class Student {
      //属性
	 String name;
      int age;
      //方法
      public void study() {
    	  System.out.println("学生学习");
      }
      public void sleep() {
    	  System.out.println("学生睡觉");
      }
}

6、创建对象以及调用属性，方法

格式：类名对象名 = new 类名();
调用属性：对象.属性名称 = 值；
调用方法：对象.方法名（参数）;
输出对象：打印的是地址值


public class HelloWord {

	public static void main(String[] args) {
           
		//创建对象，调用属性和方法
		Student s1 = new Student();
		s1.name = "张三";
		s1.age  = 22;
		System.out.println(s1.name);
		System.out.println(s1.age);
		s1.study();
		s1.sleep();
		System.out.println("华丽的分界线-------");
		Student s2 = new Student();
		s2.name = "李四";
		s2.age  = 12;
		s2.sleep();
		s2.study();
	}
}

7、构造方法

作用：
1.创建对象
2.给成员变量赋值
3.如果不写任何构造方法，java会提供一个空参构造，如果写了任意构造方法，将不再提供空参构造
格式：
public 类名（）{
//无参构造
}
public 类名（String name,int age）{
//有参构造
this.name = name;
this.age = age;
}

public class gouzao {

	public static void main(String[] args) {
		//构造方法
		//空参构造
		Student s1 = new Student();
		//调用有参构造
		Student s2 = new Student("李四",18);
		
		System.out.println(s1.name + "----" + s1.age);
		System.out.println(s2.name + "----" + s2.age);
		

	}

}

8、成员变量和局部变量

定义的位置
成员变量：类中方法外
局部变量：方法内或者方法参数，语句内
范围
成员变量：本类中都能用
局部变量：当前所属的区域（方法或语句）

9、this 关键字

this 关键字是 Java 常用的关键字，可用于任何实例方法内指向当前对象，也可指向对其调用当前方法的对象，或者在需要当前类型对象引用时使用。
假设有一个教师类 Teacher 的定义如下：

public class Teacher {
    private String name;    // 教师名称
    private double salary;    // 工资
    private int age;    // 年龄
}

在上述代码中 name、salary 和 age 的作用域是 private，因此在类外部无法对它们的值进行设置。为了解决这个问题，可以为 Teacher 类添加一个构造方法，然后在构造方法中传递参数进行修改。代码如下：
// 创建构造方法，为上面的3个属性赋初始值

public Teacher(String name,double salary,int age) {
    this.name = name;    // 设置教师名称
    this.salary = salary;    // 设置教师工资
    this.age = age;    // 设置教师年龄
}

在 Teacher 类的构造方法中使用了 this 关键字对属性 name、salary 和 age 赋值，this 表示当前对象。this.name=name语句表示一个赋值语句，等号左边的 this.name 是指当前对象具有的变量 name，等号右边的 name 表示参数传递过来的数值。

10、static关键字

作用：无需创建对象，直接用类名，点，的方式调用
可以使用在方法和变量
特点：静态只能直接访问静态

public class Teacher {
	
	String name;
	static int age;
	public void eat() {
		System.out.println("老师上课");
		
	}
	
	public static void sleep() {
		System.out.println("老师睡觉");
	}

}
public class sta {
	public static void main(String[] args)
	{
		//static 关键字
		Teacher.age = 30;//加了静态关键字 可以直接.name 调用
		Teacher.sleep();
		
		
		
	}
}

11、java修饰符

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

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

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

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

protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。注意：不能修饰类（外部类）。
在这里插入图片描述

12、面向对象三大特征之封装

封装：即隐藏对象的属性和实现细节，仅对外公开接口，控制程序中属性的读和写的访问级别
简单理解：
1.提高了代码的阅读性
2.提高了代码的可维护性
3.无需关心内部实现，只需调用即可

public class phone {
	//创建一个手机类
	private String brand;
	private int price;
	
	public void setBrand(String brand) {
		this.brand = brand;
	}
	
	public String getBrand() {
		return this.brand;
	}
	public class diaoyon {
	public static void main(String[] args) {
		//封装 只能通过调用方法来调用属性
		phone p = new phone();
		p.setBrand("华为");
		System.out.println(p.getBrand());
		
	}
}

   //
}

13、面向对象的第二个特征继承

继承：子承父业
两个类之间可以通过extend关键字来描述父子关系，子类便可以拥有父类的公共方法和公共属性
优点
1.提高了代码复用性
2.代码的维护性更高

public class father {
	
	//父类
	public String name;
	private int age;
	
	public void show() {
		System.out.println("show");
	}
	public void peint() {
		System.out.println("print");
	}

}
public class son extends father{
	//子类

}
public class jiceng {
	public static void main(String[] args) {
		//继承
		son s =new son();
		s.name = "李四";
		s.show();
		System.out.println(s.name);
	}
}