java 日常归纳

java方法返回多个值的办法

package atguigu1.day08;

public class MethodTest1 {
    public static void main(String[] args) {
        //一个方法至多有一个返回值  [思考，如何返回多个结果, 1.使用数组，2. 对象]
        A a = new A();
        //使用数组
        int[] sumAndMinus = a.getSumAndMinus(1, 4);
        System.out.println("两个数的和为：" + sumAndMinus[0]);
        System.out.println("两个数的差为：" + sumAndMinus[1]);

        //对象
        MyRes sumAndMinus2 = a.getSumAndMinus2(100, 12);
        System.out.println("和：" + sumAndMinus2.sum);
        System.out.println("差：" + sumAndMinus2.minus);

    }
}
class A{
    //返回两个数的和 差
    //返回类型是数组
    public int[] getSumAndMinus(int a1, int a2){
        //创建数组
        int arr[] = new int[2];
        arr[0] = a1 + a2;
        arr[1] = a1 - a2;
        return arr;
    }

    //返回类型是 创建对象
    public MyRes getSumAndMinus2(int a1, int a2){
        MyRes myRes = new MyRes();
        myRes.sum = a1 + a2;
        myRes.minus = a1 - a2;
        return myRes;
    }

}
class MyRes{
    int sum;
    int minus;
}

杨辉三角

public class  YangHui{

	public static void main(String[] args) {
		/*使用二维数组打印一个 5 行杨辉三角   <<九章算法>> <<杨辉算法>>
		1                    
		1 1
		1 2 1
		1 3 3  1
		1 4 6  4  1
		1 5 10 10 5 1
			
			分析
			1. 一共有 5 行
			2. 每行有 个数，和行数相等  , 比如 1行 = 1数   2 行  = 2 数 3 行 = 3数
			3. 从第三行开始，对于 非第一个元素和最后一个元素，她的值 arr[i][j]
			arr[i][j] = arr[i-1][j] + arr[i-1][j-1]; //分析

			//代码-走代码
		*/
		
		//定义二维数组，该二维数组的行可以确定，列是变化的，需要动态的赋值
		int yangHui[][] = new int[5][]; 
		for( int i = 0; i < yangHui.length; i++) {//i表行
			//每一行，动态分配
			yangHui[i] = new int[i+1];
			//遍历 yangHui[i]   分配值
			//规律我做了分析
			for( int j = 0; j < yangHui[i].length; j++) {
				
				//对于每行的第一个元素和最后一个元素，1
				if( j == 0 || j == yangHui[i].length - 1) {
					yangHui[i][j] = 1;
				} else {
					yangHui[i][j] = yangHui[i-1][j] + yangHui[i-1][j-1];
				}
			}

		}

		//看看效果

		for( int i = 0; i < yangHui.length; i++) {//i表行
			
			for( int j = 0; j < yangHui[i].length; j++) {
				
				System.out.print( yangHui[i][j] + "\t");
			}
			System.out.println();

		}



	}
}

java用方法实现数组的拷贝

package atguigu1.day08;

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

        //数组的 拷贝

        
        MyTools myTools = new MyTools();
        int arr[] = {1,2,3,4,5};
        int[] arrNew = myTools.copyArray(arr,2);
        //输出arr 和 arrNew
        myTools.printArr(arr);
        myTools.printArr(arrNew);

    }
}

class MyTools{

    //输出以为数组的方法
    public void printArr(int arr[]){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
        System.out.println();
    }
    public int[] copyArray(int[] arr, int count){
        //确定拷贝的个数
        count = count > arr.length ? arr.length : count;
        //System.out.println(count);

        //创建新的数组
        int arrNew[] = new int[count];
        //拷贝
        for (int i = 0; i < count; i++) {
            arrNew[i] = arr[i];
        }
        return arrNew;
    }
}

克隆对象， 地址相同和地址不同

package atguigu1.day08;

public class MethodTest9 {
    public static void main(String[] args) {
        /*
        3)	编写一个方法copyPerson，可以复制一个Person对象，返回复制的对象。克隆对象。。，
        注意得到新对象和原来的对象是两个独立的对象，只是他们的属性相同

        //分析
        1. 方法名  copyPerson
        2. 形参 Person
        返回值 Person
         */

        S s = new S();
        //克隆对象
        Person p = new Person();
        p.name = "孙悟空";
        p.age = 421;

        Person p1 = p ;//p 和 p1 相同  s.copyPerson(p); //p和p1 不相同

        System.out.println("p1.anme="  + p1.name + " p1.age=" + p1.age);


    }
}
class S{
    public Person copyPerson(Person p){
        //创建 一个新的Person
        Person person = new Person();
        //给person 赋值
        person.name = p.name;
        person.age = p.age;

        return person;

    }
}

class Person{
    public String name;
    public int age;
}

java instanceof 的使用

package com.atguigu.day12;


/*
 * instanceOf 比较操作符，用于判断某个对象的类型是否为XX类型或XX类型的子类型 【举例说明】
 */
public class InstanceOfDemo {

	public static void main(String[] args) {
		Object obj1 = new Object();
		String str1 = new String("Hello");
		
		Taiger taiger = new Taiger();
		
		//判断 obj1 是不是 object类 或是不是object 子类型
		System.out.println(obj1 instanceof Object); //true
		System.out.println(str1 instanceof Object); //true
		System.out.println(taiger instanceof Object); //true
		System.out.println(taiger instanceof Monster); //true
		System.out.println(obj1 instanceof Taiger); //false
	}

}

class Taiger extends Monster{
	
}

class Monster{
	
}

多态案例

package com.atguigu.day12;

public class TestFiledMethod {

	public static void main(String[] args) {
		Sub2 sub = new Sub2();
		System.out.println(sub.count); //20
		sub.display(); //20
		/*
		 * 多态：
		 * 属性：编译看左边，运行看左边
		 * 方法：编译看左边，运行看右边
		 */
		Base2 s = sub;  //s 编译类型
		System.out.println(s.count); //10
		s.display();  //20
		
	}

}

class Base2{
	int count =10;
	public void display(){
		System.out.println(this.count);
	}
}

class Sub2 extends Base2{
	int count = 20;
	public void display(){
		System.out.println(this.count);
	}
}

java 动态绑定机制案例

package com.atguigu.day12;

public class PolyExam03 {

	public static void main(String[] args) {
		AAA a = new BBB();  //向上转型
		System.out.println(a.sum()); //40
		System.out.println(a.sum1()); //30 
		
		System.out.println("注销后的测试");
		
		System.out.println(a.sum()); 
		// 30 方法里的 getI 是BBB类中的，对于属性即变量，编译看左边，运行看左边类
		System.out.println(a.sum1()); 
		//20  这个 I 就是本类中的 i
	}

}
/*
 * java 的 动态绑定机制
 * 当调用对象 方法时候，该方法会和该对象 的 运行类型绑定（右边类型）
 * 当调用对象属性时，没有动态绑定机制，哪里声明哪里使用。
 */

class AAA {
	public int i = 10;

	public int sum() {
		return getI() + 10;
	}

	public int sum1() {
		return i + 10;
	}

	public int getI() {
		return i;
	}

}

class BBB extends AAA {

	public int i = 20;

//	public int sum() {// 注销
//		return i + 20;
//	}

	public int getI() {
		return i;
	}

//	public int sum1() {// 注销?
//		return i + 10;
//	}

}

多态数组、冒泡排序、instanceof、向下转型综合案例

package com.atguigu.day12;

/*
 * 多态数组的练习
 */
public class PolyArr {

	public static void main(String[] args) {
		Person person[] = new Person[5];
		// 多态数组, 可以使用多态数组来管理多个子类对象

		person[0] = new Person("jack", 30);
		person[1] = new Student("smith", 26);
		person[2] = new Student("tom", 20);
		person[3] = new Teacher("joker", 40);
		person[4] = new Teacher("king", 39);
		for (int i = 0; i < person.length; i++) {
			System.out.println(person[i]);
		}

		// 冒泡排序
		Person temp = null; // 中间变量
		for (int i = 0; i < person.length - 1; i++) {
			for (int j = 0; j < person.length - 1 - i; j++) {
				// 从小到大，按年龄属性排序
				if (person[j].getAge() > person[j + 1].getAge()) {
					temp = person[j];
					person[j] = person[j + 1];
					person[j + 1] = temp;
				}
			}
		}
		// 输出排序后的结果
		System.out.println("========================");
		for (int i = 0; i < person.length; i++) {
			System.out.println(person[i]);
		}

		// 遍历persons数组，调用学生的study 和 老师的 teach
		// 体会到 instanceof 和 向下转型的实际应用场景..
		
		System.out.println("######################");
		for (int i = 0; i < person.length; i++) {
			if(person[i] instanceof Student){
				//一定先判断类型，然后在向下转型，再调用方法
				//如果是
				//向下转型
				((Student)person[i]).study();
			}else if(person[i] instanceof Teacher){
				//如果是
				//向下转型
				Teacher tea = (Teacher)person[i];
				tea.teach();
			}else
				System.out.println("Person类");
		}
	}

}

/*
 * 应用实例(课堂练习):现有一个继承结构如下： 要求创建五个年龄不等的Person、Student [2]和Teacher[2]对象，
 * 并将他们按年龄排序输出(冒泡)， 调用say方法输出name和age，看输出情况.
 */
class Person {
	private String name;
	private int age;

	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	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;
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}

}

class Student extends Person {

	public Student(String name, int age) {
		super(name, age);
		// TODO Auto-generated constructor stub
	}

	public void study() {
		System.out.println("学生 " + getName() + " 正在学习....");
	}

}

class Teacher extends Person {

	public Teacher(String name, int age) {
		super(name, age);
		// TODO Auto-generated constructor stub
	}

	public void teach() {
		System.out.println("老师 " + getName() + " 正在讲课....");
	}

}

练习题，题在代码中

package com.atguigu.day12;

public class PolyParameter {

	public static void main(String[] args) {

		Worker3 worker3 = new Worker3("佩奇", 200, 8);
		
		PolyParameter polyParameter = new PolyParameter();
		polyParameter.showEmpAnnal(worker3);	//佩奇 工资1600.0
		
		Manager3 manager3 = new Manager3("乔治", 250, 10, 6000);
		polyParameter.showEmpAnnal(manager3); 
		//经理的方法被调用~
//		乔治 工资8500.0




		polyParameter.testWork(worker3);//		 工人 佩奇 在工作中..
		polyParameter.testWork(manager3);//		经理 乔治 在管理....
		
	}

	// 测试类中添加一个方法showEmpAnnal(Employee e)，
	// 实现获取任何员工对象的年工资,并在main方法中调用该方法
	// 这里因为，我的形参是 父类，因此，子类对象可以，直接传到
	// 体现了 多态参数特点
	public void showEmpAnnal(Employee3 e) {
		System.out.println(e.getName() + " 工资" + e.getAnnual());
	}
	//测试类中添加一个方法，testWork,如果是普通员工，
		//则调用work方法，如果是经理，则调用manage方法
		//走一个代码 【多态 + instanceof + 向下转型】
		public void testWork(Employee3 e) {
			//先判断，再向下转型，再调用方法
			if(e instanceof Worker3) {
				//向下转型
				((Worker3)e).work();
			} else if(e instanceof Manager3) {
				//向下转型
				((Manager3)e).manage();
			} else {
				System.out.println("不处理");
			}
		}


}

/*
 * 应用实例2: • 定义员工类Employee3，包含姓名和月工资[private]，
 * 以及计算年工资getAnnual的方法。普通员工(Worker3)和经理(Manager3)继承了员工，
 * 经理类多了奖金bonus属性和管理manage方法， 普通员工类多了work方法， 普通员工和经理类要求分别重写getAnnual方法
 * 
 * 
 */
class Employee3 {
	private String name;
	private double monSal; // 月工资
	private int salMon; // 干多少月

	public Employee3(String name, double monSal, int salMon) {
		super();
		this.name = name;
		this.monSal = monSal;
		this.salMon = salMon;
	}

	public String getName() {
		return name;
	}

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

	public double getMonSal() {
		return monSal;
	}

	public void setMonSal(double monSal) {
		this.monSal = monSal;
	}

	public int getSalMon() {
		return salMon;
	}

	public void setSalMon(int salMon) {
		this.salMon = salMon;
	}

	public double getAnnual() {
		return monSal * salMon;
	}

}

class Worker3 extends Employee3 {

	public Worker3(String name, double monSal, int salMon) {
		super(name, monSal, salMon);
		// TODO Auto-generated constructor stub
	}

	// 特有方法
	public void work() {
		System.out.println(" 工人 " + getName() + " 在工作中..");
	}

	// 重写getAnnual 方法
	@Override
	public double getAnnual() {
		// TODO Auto-generated method stub
		return super.getAnnual();
	}
}

class Manager3 extends Employee3 {
	private double bonus; // 奖金

	public Manager3(String name, double monSal, int salMon, double bonus) {
		super(name, monSal, salMon);
		this.bonus = bonus;
	}

	public double getBonus() {
		return bonus;
	}

	public void setBonus(double bonus) {
		this.bonus = bonus;
	}

	// 特有的方法
	public void manage() {
		System.out.println("经理 " + getName() + " 在管理....");
	}

	// 重写getAnnual 方法
	@Override
	public double getAnnual() {

		// 对于经理而言，多一个 bonus ，所以加入即可
		System.out.println("经理的方法被调用~");
		return super.getAnnual() + bonus;
	}

}