java面向对象

20200110

public void 修饰是非静态方法，该类方法属于对象，在对象初始化（new Object()）后才能被调用；
public static void 修饰是静态方法，属于类，使用类名.方法名直接调用。 Static可以被main直接调用，而非static方法不可以

方法

引用类型参数的传递，调用方的参数变量指向的事同一个对象。双方任意一方对这个对象的修改都会影响对方（因为只想同一个对象）
①

public class duoTai {
	public static void main(String []args) {
		person p=new person();
		String[] i=new String[]{"11","22"};
		p.setAge(i);			//传入i数组
		System.out.println(p.getAge());//11   22
		i[0]="99";		//i数组的第一个元素改成bart
		System.out.println(p.getAge());//99   22
	}
}
 class person{
	private String age[]];
	public String getAge() {
		return this.age[0]+"  "+this.age[1];
	}
	public void setAge(String[] age) {
		this.age=age;
	}
}

②

public class duoTai{
	public static void main(String []args) {
		person p=new person();
		String s="bmob";		
		p.setName(s);		//传入bmob变量
		System.out.println(p.getName());
		s="wode";
		System.out.println(p.getName());
	}
}
class person{
	String name;
	public String getName(){
		return name;		//相当于this。name
	}
	public void setName(String name) {
		this.name=name; 	//前面this不可少，少了就是局部变量name了
	}
}

构造方法
创建实例的时候，实际上是通过构造方法来初始化实例的。我们先来定义一个构造方法，能在创建Person实例的时候，一次性传入name和age，完成初始化

class duoTai{
	public static void main(String []args) {
		person p=new person("tq",29);
		System.out.println(p.getAge());
		System.out.println(p.getName());
	}	
}
class person{
	private int age;
	private String name;
	public person(String name,int age) {
		this.name=name;
		this.age=age;
	}
	public String getName() {
		return name;
	}
	public int getAge() {
		return age;
	}
}

方法重载
如果想带参数的构造方法和不带参数的构造方法同时存在，那就把两个构造方法都定义出来

class duoTai {
	public static void main(String[] args) {
		person p = new person("tq", 29);
		
		person p1=new person();
		
		System.out.println(p.getAge());
		System.out.println(p.getName());
	}
}

class person {
	private int age;
	private String name;
	
	public person() {}
	
	public person(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public int getAge() {
		return age;
	}
}

方法重载
方法名相同，但是各自参数不同，称为方法重载
方法重载的返回值类型通常都是相同的。
方法重载的目的是，功能类似的方法使用同一名字，更容易记住，因此，调用起来更简单。

class duoTai {
	public static void main(String[] args) {
		person ming = new person();
		person hong = new person();
		ming.setName("小唐");
		hong.setName("小王");
		System.out.println(hong.getName());
		System.out.println(ming.getName());
		
		System.out.println(ming.getName("提前"));
		System.out.println(hong.getName("开始看"));
		
		System.out.println(hong.setName("ll", "pp"));
	}
}

class person {
	private String name;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name=name;
	}
	
	public String getName(String name) {
		this.name=name;
		return this.name;
	}
	
	public String setName(String one,String two ) {
		return one+"	"+two;
	}	
}

继承

class duoTai {
	public static void main(String[] args) {
		person p=new person("小米",13);
		student s=new student(12,"xiaomi",99);
		student st=new student(13,"laoqi");
		student ps=new primaryStudent(1,1,1,"ww");//向下转型
		System.out.println(ps.getAge()+" "+p.getAge());
	}
}

class person {
	protected String name;
	protected int 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;
	}

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

class student extends person {
	protected int grade;

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

	public student(int age, String name) {
		super(name, age);
	}

	public int getGrade() {
		return grade;
	}
}

class primaryStudent extends student {
	protected int num;

	public int getNum() {
		return num;
	}

	public primaryStudent(int age, int grade, String name) {
		super(age, name, grade);
		this.num = num;
	}

	public primaryStudent(int age, int num, int grade, String name) {
		super(age, name);
		this.grade = grade;
		this.num = num;
	}
}

多态

class duoTai{
	public static void main(String []args) {
		
		Gongzi G=new Gongzi(6000);
		ewai e=new ewai(7000);
		System.out.println(G.getTax()+e.getTax()+"税");//900.00税
	}
}
class Gongzi{
	protected double gongzi;
	public Gongzi(double gongzi) {this.gongzi=gongzi;}
	public double getTax() {
		if(gongzi<=5000) {
			return 0;
		}return (gongzi-5000)*0.2;}
}
class ewai extends Gongzi{
	public ewai(double gongzi) {
		super(gongzi);
	}
	public double getTax() {
		return gongzi*0.1;
	}
}

抽象类
抽象类关键词：abstract

class duoTai{
	public static void main(String []args) {
		gongzi gz=new gongzi(7000);
		gaofei gf=new gaofei(600);
		System.out.println(gz.getTax()+gf.getTax());
	}
}
abstract class Income{
	protected double income;
	public Income(double income) {
		this.income=income;
	}
	public abstract double getTax();
}
class gongzi extends Income{
	public gongzi(double income) {
		super(income);
	}
	public double getTax() {
		if(income<=5000) {return 0;}return (income-5000)*0.2;
	}
}
class gaofei extends Income{
	public  gaofei(double income) {
		super(income);
	}
	public double getTax() {return income*0.2;}
}

接口
①一个抽象类没有字段，所有方法都是抽象方法那么就可以把该抽象类该写为接口：interface
②当一个具体的class去实现interface时，需要使用implements
③default方法的目的是当我们需要给接口新增一个方法时，会涉及到修改全部子类，如果新增的是defalut方法就不需要全部修改，只需要在需要覆写的地方去覆写新增方法

class duoTai {
	public static void main(String[] args) {
		Income i=new gz(6000);
		Income n=new ewai(100);
		i.tax();
		n.tax();
	}
}

interface Income {
	double getTax();
	default void tax() {
		System.out.println(getTax());
	}
}

class gz implements Income {
	protected double money;

	public gz(double money) {
		this.money = money;
	}

	public double getTax() {
		if (money <= 5000) {
			return 0;
		}
		return (money - 5000) * 0.2;
	}
}
class ewai extends gz{
	public ewai(double gz) {
		super(gz);
	}
	public double getTax() {
		return money*0.1;
	}
}