java 面向对象练习2

/*

• 类中属性的声明与使用
• 属性（成员变量）与局部变量的区别
• 1，相同点
• 1.1定义变量的形式都是：数据类型 变量名 = 变量值
• 1.2都需要先声明，再使用
• 1.3变量都有其对应的作用域和生命周期。
• 2，不同点
• 2.1 位置不同
• 属性（成员变量）：直接声明在类的一对{}内部
• 局部变量：声明在方法内，方法形参，代码块内，构造器形参，构造器内部的变量
• 2.2 权限修饰符不同
• 属性：可以在声明属性的同时，通过使用权限修饰符指明其权限
• 常用权限修饰符：public private protected，缺省(default)，
• public :可以被本类，本包，子类，外部类使用
• private：可以被类内部使用，不可以被本包，子类，外部包使用
• protected：可以被本类，本包，子类使用，不可以被外部包使用
• 缺省(default)：可以被本类，本包使用，不可以被子类，外部包使用
• 其他：static ，final，abstract 不是权限修饰符
• 初级学习暂用缺省
• 局部变量：不能使用权限修饰符，可以用final；
• 2.3 默认初始化值
• 属性 ：类的属性根据其类型都有默认初始化值，与数组的初始化值相同
• 整形（byte，short，int，long）初始值0
• 浮点型（float，double）初始值0.0
• 字符型（char） 初始值0 或’\u0000’
• 布尔型（boolean）初始值false
• 引用数据类型（类，数组。接口）初始值null
• 局部变量：
• 没有默认初始化值，在调用局部变量之前必须显式赋值
• 局部变量中的形参在调用时赋值即可
• 2.4 在内存中加载的位置不同
• 属性（非Static情况下）：加载到堆空间中，static情况下加载在方法区中
• 局部变量：加载到虚拟机栈空间中

*/

/*-------------------------------------------------------------

• 类中方法的声明与使用
• 方法描述类所具有的功能，也叫函数或过程，java中的方法不能独立存在，只能在类中定义。
• 将功能封装为方法的目的是可以实现代码复用，简化代码。
• 方法的声明格式：
• 修饰符 （是否static）（是否有返回值）方法名(参数类型1 形参1,参数类型2 形参2,…){

•       方法体;
  

•       return 返回值;//如果无返回方法名前加void
  

• }
• 说明1：java 的权限修饰符四种：public ，private，protected，缺省default前两种常用
• 说明2：返回值类型：有返回值，无返回值。
• 如果方法有返回值则必须在方法声明时，指定返回值类型，同时方法中需要使用return关键字返回指定类型的变量或常量数据
• 如果方法没有返回值，则方法声明时，使用void来表示，通常没有返回值的方法体中不使用return，如果使用只能“return;”
• 表示结束此方法，return后不可再写表达式。
• 设计方法时是否返回数值：1，看功能需求2，按经验处理
• 说明3： 方法名属于标识符，命名需遵循标识符设计规范，避免关键字，见名知意
• 说明4：方法可以不声明形参，也可以声明多个形参。
• 设计方法时要不要定义形参：1，看功能需求2.按经验处理
• 说明5：方法体，方法功能的体现
• return关键字的使用：
• 1，使用范围：方法体中
• 2，作用：1，结束一个方法。2，针对有返回类型的方法，使用“return 数据”，结束方法的同时返回数据
• 3，return之后不可以再声明执行语句。
• 方法的调用
• 方法通过方法名被调用，且只有被调用时才会执行
• 方法的使用中，可以调用当前类的属性与方法
• 如果方法A中又调用方法A，则方法A是递归方法
• 方法的注意事项
• 1，方法被调用一次就会执行一次
• 2，没有具体返回值的情况下方法体中可以没有return语句，如果有仅用来结束方法
• 3，定义方法时，方法的结果应该返回给调用者，交给调用者处理
• 4，方法中只能调用方法或者属性，不能在方法内部再定义方法
• 5,方法之中不能再定义方法
  */

package com.atguigu.contact;
import java.util.*;
public class Object2 {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		
		//测试Parameter类
		Parameter p = new Parameter();
		System.out.println(p.isWisdom);
		System.out.println(p.name); 
		System.out.println(p.age);
		p.age = 30;
		System.out.println(p.age);
//		System.out.println(p.weight);//无法直接调用private修饰的属性
		System.out.println(p.getWeight());//可以通过方法调用weight
		p.setWeight(10);//可以通过方法修改weight
		System.out.println(p.name + "已经" + p.getWeight() + "Kg了");
		p.sleep(10);
		
		//测试Person2类
		Person2 person = new Person2();
		person.name = "jery";
		person.age = 21;
		person.sex = '女';
		person.addAge(2);//23
		int newAge = person.addAge(2);//25
		System.out.println(person.name + " is " + newAge + " years old");//25
		person.showAge();//25
		person.study(4);
		Person2 person1 = person;
		person1.addAge(10);
		person.showAge();//35
		Person2 person2 = new Person2();
		person2.showAge();//0
		person2.addAge(24);
		person2.showAge();//24
		person.showAge();//35
		
		//测试Circle 类
		Circle c = new Circle();
		System.out.println("请输入圆的半径");		
		c.setRadius(scan.nextDouble());
		//或者直接 c.radius = scan.nextDouble();
		System.out.println("圆的面积是" + c.area() );
		
		//测试Rectangle类
		Rectangle rec = new Rectangle();
		rec.print();
		System.out.println("矩形面积为" + rec.print());
		System.out.println(rec.print());//可以直接在syso内填入方法，输出图形和返回值。
		//对于JVM来说这里代表的是变量,变量值是方法的返回值
		
		//测试Rectangle1类
		Rectangle1 rec1 = new Rectangle1();
		System.out.println("请输入矩形的长度");
//		rec1.length = scan.nextInt();
		rec1.setLength(scan.nextInt());
		System.out.println("请输入矩形的宽度");
//		rec1.width = scan.nextInt();		
		rec1.setWidth(scan.nextInt());
		rec1.print();
		System.out.println("矩形的面积是 " + rec1.area());
		
		//测试Rectangle2类
		Rectangle2 rec2 = new Rectangle2();
		System.out.println("请输入矩形的长度");
		int m1 = scan.nextInt();
		System.out.println("请输入矩形的长度");
		int n1 = scan.nextInt();
		System.out.println(rec2.print(m1,n1));		
	}
}

class Parameter{
	    Boolean isWisdom = true;
		public String name = "kenny";
		protected int age = 20;
		private double weight = 60.5;//一定要保持体重	
		public void work() {
			System.out.println(name + "工作了一整天");
		}
		public void sleep(int hour) {
			work();//方法内可以调用类中的方法与属性，不需要实例化
			System.out.println(name + "睡了" + hour + "小时");
			//sleep(10);  //会报错，因为这种递归无法结束，局部变量被重复创建，无法回收，栈空间很快溢出
		}
		public double getWeight() {
		return weight;
		}		
		public double setWeight(double i) {
			System.out.println(name + "又胖了" + i + "Kg");
		return	weight += i;		   
		}
		
	}
class Person2{//同一个包内的类名不能重复？
	String name;
	int age;
	char sex;
	public void study(int hour) {
		System.out.println(name + " has been studying for" + hour +"hours");
	}
	public void showAge() {
		System.out.println(name + " is already" + age + "years old");
	}
	public int addAge(int i) {
		age += i;
	return age;
	}
		
}	

class Circle{
	double radius;
	public void setRadius(double i) {
		radius = i;
	}
	public double area() {
		return Math.PI * radius * radius ;	
		
	}	
}

//方法可以不返回数值，直接在方法体内输出面积
//class Circle{
//	double radius;
//	public void area() {
//		double area = Math.PI * radius * radius ;	
//      System.out.println("圆的面积是" + area); 
//	}	
//}

// 去掉setRadius方法也可以使用
// class Circle{
//	double radius;
//	public double area() {
//		return Math.PI * radius * radius ;		
//	}	
//}

// 可以单独定义方法，不定义属性,但半径更适合当做属性
//class Circle{
//	public double area(double radius) {
//		return Math.PI * radius * radius ;		
//	}	
//}
class Rectangle{
	int length = 10;
	int width = 8;
	public int print() {
		for (int i = 0; i < length; i++) {
			for (int j = 0; j < width; j++) {
				System.out.print("* ");
			}
			System.out.println();
		}
		return length * width;//可以把计算面积与打印矩形放在一个方法内，但只返回面积值
	}	
}
    
class Rectangle1{
	int length;
	int width;
	public void setLength(int m) {
		 length = m;
	}
	public void setWidth(int n) {
		 width = n;
	}
	public void print() {
		for (int i = 0; i < length; i++) {
			for (int j = 0; j < width; j++) {
				System.out.print("* ");
			}
			System.out.println();
		}
	}
	public int area() {
		 return length * width;		
	}
				
}

class Rectangle2{

	public int print(int m,int n) {
		for (int i = 0; i < m; i++) {
			for (int j = 0; j < n; j++) {
				System.out.print("* ");
			}
			System.out.println();
		}
		 return m * n;	
	}					
}