JavaSE学习笔记——类的属性和方法

类

类的成员之一：属性

• 语法格式：
  修饰符 类型 属性名 = 初值；
  说明：
  private：该属性只能由该类的方法访问。
  public：该属性可以被该类以外的方法访问。
  举例：

package practice2;

public class Person {
	public String name = "Lily";//public公有的，该变量可以在类的外部使用
	private int age;//private私有的，改变类只能在本类(Person类)中使用
	
	public void showAge() {
		System.out.println(age);
	}
}

package practice2;

public class Student {
	public static void main(String[] args) {
		Person per = new Person();
		//per.age = 1;//在Person类的外部调用Person类的私有(private)属性，编译不通过
}

变量的分类

成员变量与局部变量
(1) 在方法体外、类体内声明的变量称为成员变量。
(2) 在方法体内部声明的变量称为局部变量。

public static String sex = "男";//用static修饰的属性是类属性，不需要实例化对象，可通过-类名.属性-访问

成员变量与局部变量的主要区别

(1) 成员变量定义在类内，局部变量定义在方法内等；
(2) 成员变量有默认的初始值数值类型为0，引用类型为null，局部变量没有但必须显示初始化；
(3) 成员变量在声明时需要权限修饰符，局部变量不需要；
(4) 成员变量存储在堆内存中，局部变量存储在栈内存中；
(5) 成员变量不会自动释放内存，局部变量在作用范围结束后会自动释放内存。

类的成员之二：方法

• 语法格式：
  修饰符 返回值类型 方法名 (参数列表){
  方法体语句;
  }
  说明：
  修饰符：public、private、protected等
  返回值类型：return语句传递返回值，没有返回值时使用void。
• 举例

public class Person{
    private int age;
    public int getAge() {//声明方法getAge
           return age; 
     } 
    public void setAge(int i) { //声明方法setAge
	  age = i; //将参数i的值赋给类的成员变量age
    }
}

方法

（1）什么是方法（函数）？
方法是类或对象行为特征的抽象，也成为函数。
Java中的方法不能独立存在，所有的方法必须定义在类里。
（2）形参与实参：
形参：在方法被调用时，用于接收外部传入的数据的变量，即语法格式中参数列表部分；
实参：调用方法时，实际传给函数形参的具体数据。

• 方法的调用
  （1）用类的实例化对象调用方法；
  （2）方法中只能调用方法，不可以在方法内部定义方法。

对象的产生

• 一般使用new关键字来实例化对象，语法格式为：类名 实例化对象名 = new 类名();
• 如果创建了一个类的多个对象，对于类中定义的属性，每个对象都拥有各自的一套副本，且互不干扰。
• 举例

public class Zoo{
    public static void main(String args[]){
	Animal xb=new Animal();
	Animal xh=new Animal();
	xb.legs=4;
	xh.legs=0;
	System.out.println(xb.legs);   //4
	System.out.println(xh.legs);   //0
	xb.legs=2;
	System.out.println(xb.legs);   //2
	System.out.println(xh.legs);   //0
    }  
}

成员变量类型	初始值
byte	0
short	0
int	0
long	0L
float	0.0f
double	0.0d
char	空
boolean	false
引用类型	null

匿名对象

• 不定义实例化对象名称，直接使用new的方法产生的对象称为匿名对象，如：
  new person().shout();

• 使用情况：
  （1）该对象只需要进行一次方法调用；
  （2）作为实参传递给一个方法。

注意

类的访问机制：

• 在同一个类中的访问机制： 类中的方法可以直接访问类中的成员变量。（例外：static方法访问非static的成员变量，编译不通过。）

• 在不同类中的访问机制： 先创建要访问类的对象，再用对象访问类中定义的成员。

方法重载

• 重载的概念
  在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可
• 重载的特点
  与返回值类型无关，只看参数列表，且参数列表必须不同(参数个数、参数顺序、参数类型)。 调用时，根据方法参数列表的不同来区别。
• 举例

public class PrintStream{
	public static void print(int i) {……}
	public static void print(float f) {……}
	private static void print(String s) {……}
	public static void main(String[] args){	
		print(3)；
		print(1.2f)；
		print(“hello!”)；
	}
}

判 断：
与  void show(int a,char b,double c){} 构成重载的有：
a） void show(int x,char y,double z){}	//no
b） int show(int a,double c,char b){}   //yes顺序不同也是重载
c)  void show(int a,double c,char b){}  //yes顺序不同也是重载
d)  boolean show(int c,char b){}  //yes
e)  void show(double c){}  //yes
f)  double show(int x,char y,double z){}  //no
g)  void shows(){double c}  //no

练习

1. 创建一个Person类，其要求如下：

• 创建Person类的对象，设置该对象的name、age和sex属性，
  调用study方法，输出字符串“studying”；
  调用showAge()方法显示age值；
  调用addAge()方法给对象的age属性值增加2岁。

package practice2;

public class Test {
	public static void main(String[] args) {
		Person per = new Person();
		per.showAge();
		System.out.println(per.addAge());
	}
}

class Person {
	
	public String name =  "XiaoMing";
	public int age = 20;
	public String sex = "男";
	
	public void study() {
		System.out.println("Studying");
	}
	public void showAge() {
		System.out.println("年龄是：" + age);
	}
	public int addAge() {
		return age + 2;
	}
}

2. 利用面向对象的编程方法，设计类Circle计算圆的面积。

package practice2;

public class Test {
	public static void main(String[] args) {
		Circle cir = new Circle();
		System.out.println("面积是：" + cir.countArea(5.12));
	}
}

class Circle {
	public double radius;
	
	public double countArea(double r) {
		return 3.14 * r * r;
	}
}

3. 判断下面方法哪些是重载，哪些不是重载

与void show(int a,char b,double c){}构成重载的有：
void show(int x,char y,double z){}   //no
int show(int a,double c,char b){}   //yes顺序不同也是重载
c)  void show(int a,double c,char b){}  //yes顺序不同也是重载
d)  boolean show(int c,char b){}  //yes
e)  void show(double c){}  //yes
f)  double show(int x,char y,double z){}  //no
g)  void shows(){double c}  //no

4. 编写程序，定义三个重载方法并调用，方法名为mOL。三个方法分别接收一个int参数、两个int参数、一个字符串参数。分别执行平方运算并输出结果，相乘并输出结果，输出字符串信息。在主类的main ()方法中分别用参数区别调用三个方法。

package practice2;

public class Test {
	public static void main(String[] args) {
		MethodOverride met = new MethodOverride();
		System.out.println(met.mOL(3));
		System.out.println(met.mOL(2, 3));
		System.out.println(met.mOL("Good"));
	}
}

class MethodOverride {
	public int mOL(int m) {
		return m*m;
	}
	
	public int mOL(int m, int n) {
		return m*n;
	}
	
	public String mOL(String str) {
		return str;
	}
}

5. 定义三个重载方法max()，第一个方法求两个int值中的最大值，第二个方法求两个double值中的最大值，第三个方法求三个double值中的最大值，并分别调用三个方法。

package practice2;

public class Test {
	public static void main(String[] args) {
		MaxOverride max = new MaxOverride();
		max.max(3, 4);
		max.max(3.14, 5.12);
		max.max(1.02, 7.28, 4.56);
		
	}
}

class MaxOverride {
	public void max(int a, int b) {
		int k = a > b ? a : b;
		System.out.println("这两个数中的最大值为：" + k);
	}
	public void max(double a, double b) {
		double k = a > b ? a : b;
		System.out.println("这三个数中的最大值为：" + k);
	}
	public void max(double a, double b, double c) {
		double k = a > b ? (a > c ? a : c) : (b > c ? b : c);
		System.out.println("这三个数中的最大值为：" + k);
		
//		double max = a;
//		if(a > b && a > c) {
//			max = a;
//		}
//		if(b > a && b > c) {
//			max = b;
//		}
//		if(c > a && c > b){
//			max = c;
//		}
//		System.out.println("这三个数中的最大值为：" + max);
	}
}