JAVA学习笔记_Day4_OOP(面向对象)

Java编程基础——复习

java编程基础：
　
　　1.基本数据类型
　　2.变量
　　3.运算符
　　4.语句 　分支选择语句　条件循环语句
　　5.方法　方法的五要素　（递归方法）
　　6.数组 　　
　　面向过程编程：把解决问题的思路分解成若干个步骤，每个步骤用方法实现，然后按照一定的顺序调用方法
　　程序　＝　数据结构　＋　算法
　　　　　　　变量/数组　　　解决问题的思路

Java面向对象（OOP）

面向对象中关键的类和对象，什么是类？什么是对象？
类：类是一类事物的总称　泛指一类事物　是一个抽象的概念
对象：对象是类实例化和具体化的结果　特指一个具体的事物
　　例如：电脑　　我正在使用的电脑
　　　　前者是一类事物的总称（脑海中我们可以想象出其模样和功能——抽象）
　　　　后者则为一个具体的事物（具体存在的事物）

Java中类和对象的表示

class关键字
　　class：描述一类事物的特征和行为，并将特征用变量表示，行为用方法描述
定义声明一个类：
　　修饰词（public 、default）class 类名{
　　　　属性：
　　　　　　修饰词 类名 属性名；
　　　　方法：
　　　　　　修饰词 返回值类型 方法名（参数列表）{
　　　　　　　　方法体
　　　　　　}　
　　}
修饰词有：public 　protected 　private 　默认（不写）
　　一个java文件中只能有一个public的类，而且这个类名和文件名相同

创建对象：
　　new　类名();　//实例化对象
　　类名　变量名　＝　new　类名();　//前者为引用的变量　后者为实例化的对象
引用数据类型：
　　存储的为对象的地址信息，而非对象的属性
访问对象属性的方法：
　　通过　引用变量.属性名　可以访问该引用变量所引用的对象的属性
　　通过　引用变量.方法名（参数列表）　可以调用该引用变量所引用对象的方法

练习：创建一个类
　　　属性：点的坐标（即x和y的值）
　　　方法：点到点的距离

class Point{
	double x;
	double  y;
	Point(double x,double y){
		this.x = x;
		this.y = y;
	}
	double Myfunction(Point p){
		return Math.sqrt((x-p.x)*(x-p.x)+(y-p.y)*(y-p.y))
	}
	double Myfunction(double x,double y){
		return Math.sqrt((this.x-x)*(this.x-x)+(this.y-y)*(this.y-y))
	}
}
public class Test{
	public static void main(String[]args){
		Point p = new Point(2,3);
		Point p1 = new Point(4,5);
		System.out.println(p.Myfunction(p1));
		System.out.println(p.Myfunction(4,5));
	}
}

在上面的例子中，类名为Point，但是其内部有一个与之同名的Point的方法且没有返回值类型，这一类方法就称为构造方法
假使没有定义这个Point方法，java中默认会创建一个隐形的空构造方法，当然，这样的话，在实例化对象时就不需要传入参数用于初始化了。
如果一个类没有实现构造方法，那么编译器会自动生成一个默认的无参构造方法，如果程序员自己手动实现了一个构造方法，那么编译器将不会再自动生成无参的构造方法

默认值初始化

没有创建构造方法时，那么就会生成一个无参的构造方法，但是这样初始化的值为多少呢？
byte 　 short 　int　 long 　 0
float 　double 　　　　　　 0.0
char 　　　　　　　　　　 ‘\u0000’
boolean 　　　　　　　　　 false
引用数据类型 　　　　　　　 null

重载

在上面的例子中，我定义了两个方法名相同的方法，但是其参数列表不同，这就称为方法重载
重载的定义：
　同意作用域下，方法名相同，参数列表不同就构成方法重载
　1.前提条件　作用域相同（目前理解为同一个class内）
　2.方法名　必须相同
　3.参数列表不同　(1)参数类型不同　(2)参数个数不同　与形参名字无关
　4.与返回值类型无关
　　　如果形参类型和个数一致，那么编译将报错
在调用重载的方法时，调用哪一个方法是由形参列表决定的

举例：

class Pay{
	int pay(int x){
		return 1;
	}
	int pay(double x){
		return 2;
	}
	int pay(int x,int y){
		return 3;
	}
	int pay(String x){
		return 4;
	}
}
public class Test{
	public static void main(String[]args){
		Pay p = new Pay();
		p.pay(1);//其调用的方法返回值为1
		p.pay(2.0);//返回值为2
		p.pay(1,2);//返回值为3
		p.pay("dajgdk");//返回值为4
	}
}

this引用

在方法里面，都由一个隐含的this变量　　this引用正在构造的对象或者正在调用方法的对象

练习

定义一个时间类
　　属性：年、月、日
　　方法：该日期是否合法
　　　　　该日期下一天的日期
　　　　　该日期是那一年的第几天

class Time{
	int year;
	int month;
	int day;
	Time(int year,int month,int day){
		this year = year;
		this month = month;
		this day = day;
	}
	boolean isLeap(){//判断是否为闰年
		return year%4==0&&year%100!=0||year%400==0;
	}
	boolean istrue(){//判断是否为合法日期
		if(month>0&&month<=12){
			if(month==2){
				int Day = isLeap()?29:28;
				if(day>0&&day<=Day){
					return true;
				}
			}else if(month==4||month==6||month==9||month==11){
				if(day>0&&day<=30){
					return true;
				}
			}else{
				if(day>0&&day<=31){
					return true;
				}
			}
		}
		return false;
	}
	
	int days(){//返回这一天是这一年的第几天
		switch(month){
		int days = 0;
		case 12:days+=30;
		case 11:days+=31;
		case 10:days+=30;
		case  9:days+=31;
		case  8:days+=31;
		case  7:days+=30;
		case  6:days+=31;
		case  5:days+=30;
		case  4:days+=31;
		case  3:days+=28;
		case  2:days+=31;
		case  1:days+=day;
		}
		if(isLeap()&&month>2)
			days++;
		return days;
	}
	Time nextday(){//返回下一天，返回的为Time实例化的对象
		Time d = new Time(year,month,day);
		if(day==31){
			d.day = 1;
			if(mon==12){
				d.year++;
				d.mon = 1;
			}else{
				d.mon++;
			}
		}else if(day==30){
			if(day==4||day==6||day==9||day==11){
				d.mon++;
				d.day = 1;
			}else{
				d.day++;
			}
		}else if(day==29){
			if(mon==2){
				d.mon=3;
				d.day=1;
			}else{
				d.day++;
			}
		}else if(day==28){
			if(mon==2 && !isLeap()){
				d.mon = 3;
				d.day = 1;
			}else{
				d.day++;
			}
		}else{
			d.day++;
		}
		return d;
	}
}