JavaSE (六）面向对象 -- 类的结构

个人博客网：https://wushaopei.github.io/    (你想要这里多有)

目录

一、属性（变量）

1、变量的分类：

二、方法

1、例子：

2、格式：

3、方法的说明：

4、return 关键字: 在方法中使用

5、方法的重载

6、值传递

三、构造器

1、作用：

2、格式：

3、说明：

4、属性的赋值方式有几种？

四 、案例实操

案例(1) 方法与返回值

案例（2）有返回值、无返回值

案例（3）  重载

案例（4） 值传递

案例（5）JavaBean

---

一、属性（变量）

1、变量的分类：

1.1 按照类型来分 ： 基本数据类型   vs 引用数据类型

1.2 按照位置来分 ：局部变量 vs 成员变量

 局部变量和成员变量的相同和不同点:
（1）相同点 ：

①声明的格式都一样

②先声明后使用

③都有作用域

（2）不同点：

①位置不同：

局部变量的位置：方法内，方法的形参,构造器的形参，构造器中，代码块内。
               成员变量的位置： 类的内部，方法等结构外。

②权限修饰符不同：

局部变量：没有权限修饰符
               成员变量：可以使用四种权限修饰符：public private protected 缺省的

③默认值

局部变量：没有默认值
               成员变量：
                     byte short int long -> 0
                     float double -> 0.0
                     char -> \u0000
                     boolean -> false

④内存的位置不同

局部变量 ：在栈中
               成员变量 ：在堆中

案例实操：

public class FieldTest {

	public static void main(String[] args) {

		int a = 10;
		System.out.println(a);
		//输出默认值
		new Student().value();

	}
}

class Student{

//	int a = 10;
	byte a;
	short b;
	int c;
	long d;
	float e;
	double f;
	char g;
	boolean boo;

	public void value(){
		System.out.println(a);  //10
		System.out.println(b);  //0
		System.out.println(c);  //0
		System.out.println(d);  //0
		System.out.println(e);  //0
		System.out.println(f);  //0.0
		System.out.println(g);  //0.0
		System.out.println(boo);  //false
	}

	/*
	 * 代码块
	 */
	{
		int d = 20;
	}

	/*
	 * 默认无返回值方法
	 */
	public Student(int a){
		int b = 10;
	}
	public Student(){

	}

	/*
	 * 声明无返回值方法
	 */
	public void show(int a,int b){
		int c = 10;
	}
}

二、方法

1、例子：

          public void show(){} //无参无返回值
          public int getAge(){return 10;} //无参有返回值
          public void say(String str){} //有参无返回值
          public String getName(String name){return "aa";} //有参有返回值

2、格式：

          权限修饰符   返回值类型   方法名（形参列表）{
                  方法体;
          }

3、方法的说明：

    1.权限修饰符 ：四种权限修饰符 ，public protected 缺省的 private (现阶段都写成public)
    2.返回值类型 ：void / 具体的类型
               void : 无返回值
               具体的类型 ： 基本数据类型 、引用数据类型。如果有返回值类型，
                           那么方法体中应该 有返回值 "return 具体的类型"
    3.方法名：遵守标识符的规则和规范即可 （一定要做到见名知义）
    4.形参列表 ： 形参列表中的变量可以是0个1个或多个。多个变量之间用","分开
    5.方法体：调用方法时才会执行方法体。

4、return 关键字: 在方法中使用

1.如果方法有返回值，那么"return 具体的数值类型"用来给方法的调用者返回数据，同时结束方法。
             2.如果方法没有返回值，那么"return"用来结束当前方法

5、方法的重载

方法的重载的概念:

同一个类中相同的方法名，不同的形参列表构成重载

举例：

public void add(int a,int b){
		System.out.println("int,int");
		System.out.println(a + b);
	}

	//需求?求两处double类型变量的和
	public void add(double a,double b){
		System.out.println("double,double");
		System.out.println(a + b);
	}

方法重写

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。

重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如： 父类的一个方法申明了一个检查异常 IOException，但是在重写这个方法的时候不能抛出 Exception 异常，因为 Exception 是 IOException 的父类，只能抛出 IOException 的子类异常。

如何确定类中某一个方法的调用：方法名 + 形参列表

说明：

①重载和形参列表的变量名，返回值类型，权限修饰符无关。

②形参列表不同（形参的类型，个数）

6、值传递

形参：方法声明时的参数

实参：方法调用时实际传给形参的参数值

总结：

①基本数据类型： 如果传递的数据是基本数据类型 ，实际上传递的是该变量中的具体的值。

②引用数据类型：如果传递的数据是引用数据类型，实际上传递的是该对象的地址值。

​

​

三、构造器

  1、作用：

①创建对象  

②用来给对象进行初始化

  2、格式：

权限修饰符 类名（形参列表）{

    方法体;

      }

3、说明：

①如果一个类中没有显示的定义构造器，那么在创建对象的时候会默认的创建一个空参的构造器

②一个类中可以定义多个构造器，多个构造器之间构成重载

③一个类中如果显示的定义了构造器，那么系统就不会再创建空参的构造器了

④通过构造器赋值，只能赋值一次，所以还是需要set方法的。

4、属性的赋值方式有几种？

1.默认值   2.显示赋值    3.构造器赋值   4.对象名.方法名/对象名.属性名  
 *      思考？赋值的顺序？
 *         1 ->  2 -> 3 -> 4

四 、案例实操

案例(1) 方法与返回值

public class MethodTest {

	public static void main(String[] args) {

		Animal animal = new Animal();
		animal.show();

		int a = animal.getAge();
		System.out.println(a);
		//打印出来的就是方法的返回值
		System.out.println(animal.getAge());
		//编译错误 ，因为方法没有返回值
//		System.out.println(animal.show());

		animal.say("aaaaa");
		String str = "bbbb";
		animal.say(str);

		animal.add(1,2);
		//调用方法时传递的实参的类型和个数必须和形参保持一致
		animal.info("小苍", 16);

		animal.info2();
	}
}

/*
 * 同一个包下的类名不能相同  ： The type Person is already defined
 */
class Animal{

	String name;
	int age;

	//形参列表的作用就是提醒方法的调用者给传输一些需要的数据
	public void say(String str){
		System.out.println(str + name + age);
	}

	public void add(int a,int b){
		System.out.println(a + b);
	}

	public void info(String name,int age){
		System.out.println(name + " " + age);
	}

	public void info2(){
		show(); //在同一个类中方法之间可以互相调用，在同一个类中方法也可以调用属性
//		info2(); 不要自己调用自己会出异常
	}

	/*
	 * return 关键字:
	 * 如果方法有返回值，那么"return 具体的数值类型"用来给方法的调用者返回数据，同时结束方法。
	 * 如果方法没有返回值，那么"return"用来结束当前方法
	 */
	//无参无返回值的
	public void show(){
		System.out.println("say");
		for(int i = 0; i <= 5; i++){

			if(i == 2){
//				break;
				return;
			}
			System.out.println(i);
		}
		//return; //如果没有返回值，那么return用来结束当前方法
		System.out.println("方法执行完毕");
	}

	//无参有返回值的
	public int getAge(){
//		return 10;
		int a = 20;
		return a; //return 具体的数值类型。用来返回给方法的调用者一个数据
	}
}

say
0
1
20
20
aaaaanull0
bbbbnull0
3
小苍 16
say
0
1

案例（2）有返回值、无返回值

3.1 编写程序，声明一个method方法，在方法中打印一个10*8 的矩形，在main方法中调用该方法。

3.2 修改上一个程序，在method方法中，除打印一个10*8的矩形外，再计算该矩形的面积，并将其作为方法返回值。
	在main方法中调用该方法，接收返回的面积值并打印。

3.3 修改上一个程序，在method方法提供m和n两个参数，方法中打印一个m*n的矩形，并计算该矩形的面积，
	将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。

public class MethodTest {

	public static void main(String[] args) {

		MethodTest mt = new MethodTest();
		System.out.println("area = " + mt.method(5,5));
		System.out.println("area = " + mt.method(10,8));

	}

	/*
	public void method(){
		for (int i = 1; i <= 8; i++) {
			for (int j = 1; j <= 10; j++) {
				System.out.print("*");
			}
			System.out.println();
		}
	}
	*/

	/*
	public int method(){
		for (int i = 1; i <= 8; i++) {
			for (int j = 1; j <= 10; j++) {
				System.out.print("*");
			}
			System.out.println();
		}

		return 10 * 8;
	}
	*/

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

		return m * n;
	}
}

案例（3）  重载

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

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

/*
 * JavaBeen
 *		1.类是公共的
		2.有一个无参的公共的构造器
		3.有属性，且有对应的get、set方法

 */
public class Demo {

	public static void main(String[] args) {

		Demo demo = new Demo();
		demo.mOL(10);
		demo.mOL(5, 10);
		demo.mOL("我是龙哥我最大");

		System.out.println("--------------------");

		demo.max(10.5, 12.3);
		demo.max(5, 10);
		demo.max(1.5, 2.3,3.8);
	}

	public void max(int a, int b) {
		int max = (a > b)? a : b;
		System.out.println(max);
	}

	public void max(double a, double b) {
		double max = (a > b)? a : b;
		System.out.println(max);
	}

	public void max(double a, double b,double c) {
		double max = (a > b)? a : b;
		max = (max > c)? max : c;
		System.out.println(max);
	}

	public void mOL(int a) {
		System.out.println(a * a);
	}

	public void mOL(int a, int b) {
		System.out.println(a * b);
	}

	public void mOL(String str) {
		System.out.println(str);
	}
}

案例（4） 值传递

public class ValueTra {

	public static void main(String[] args) {

		ValueTra vt = new ValueTra();

		int a = 5;
		int b = 10;
		//数据交换前的值
		System.out.println("a=" + a + " b=" + b);
		//调用方法实现数据的交换
		vt.swap(a, b);
		//数据交换后的值
		System.out.println("a=" + a + " b=" + b);

		System.out.println("-------------------引用类型的值传递-----------------");

		Value v = new Value();
		v.a = 10;
		v.b = 5;
		//数据交换前的值
		System.out.println("v.a=" + v.a + " v.b=" + v.b);
		vt.swap(v);
		//数据交换后的值
		System.out.println("v.a=" + v.a + " v.b=" + v.b);
	}

	public void swap(Value v){
		int temp = v.a;
		v.a = v.b;
		v.b = temp;
	}

	public void swap(int a,int b){
		System.out.println("swap前 a=" + a + " b=" + b);
		int temp = a;
		a = b;
		b = temp;
		System.out.println("swap后 a=" + a + " b=" + b);
	}
}

class Value{
	int a;
	int b;
}

打印结果：

a=5 b=10
swap前 a=5 b=10
swap后 a=10 b=5
a=5 b=10
-------------------引用类型的值传递-----------------
v.a=10 v.b=5
v.a=5 v.b=10

案例（5）JavaBean

public class JavaBeen {

	private String name;
	private int age;

	public JavaBeen(){

	}

	public JavaBeen(String n,int a){
		name = n;
		age = a;
	}

	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 void say(){

	}
}

案例（6） 构造器

public class AnimalTest {

	public static void main(String[] args) {

		//通过构造器赋值，只能赋值一次。
		/*
		Animal animal = new Animal("强哥",38);
		animal.show();

		Animal animal2 = new Animal();
		animal2.setName("强强哥");
		animal2.setAge(48);
		animal.show();
		*/

		System.out.println("----------------验证属性赋值的顺序-------------");

		/*
		Animal animal = new Animal(20);
		animal.setAge(60);
		animal.show(); //显示赋值和构造器赋值。
		*/

		Animal animal = new Animal();
		System.out.println(animal.getAge());

	}
}

class Animal{

	private String name;
	private int age = 4;

	//构造器 （构造方法）： 

	public Animal(){
		System.out.println("我是构造器");
	}	

	public Animal(int a){
		age = a;
		System.out.println("我是构造器" + a);
	}

	public Animal(String n,int a){
		name = n;
		age = a;
		//作一些其它方法的初始化的操作
		System.out.println("---------------");
		System.out.println("哇哇哇..................");
	}	

	public void show(){
		System.out.println(name + " " + age);
	}

	public void setName(String n){
		name = n;
	}

	public String getName(){
		return name;
	}

	public void setAge(int a){
		age = a;
	}

	public int getAge(){
		return age;
	}
}

案例（7） 权限修饰符

public class Person{

	private String namePrivate = "namePrivate";
			String name = "name";
	public  String namePublic = "namePublic";

	public void sayPublic(){
		System.out.println("sayPublic");
	}

	void say(){
		System.out.println("say");
	}

	private void sayPrivate(){
		System.out.println("sayPrivate");
	}

	/*
	 * 在类的内部所有的权限修饰都可以进行调用
	 */
	public void show(){
		sayPublic();
		sayPrivate();
		say();

		System.out.println(name);
		System.out.println(namePrivate);
		System.out.println(namePublic);
	}

}

main 方法：

public class PersonTest {

	public static void main(String[] args) {
		Person person = new Person();

		//在其它的类中进行调用（同一个包中）
		System.out.println(person.name);
		System.out.println(person.namePublic);

		/*
		 * 本包中可以调用   - public 缺省的  protected(后面再讲)
		 *
		 * 在A类中不能调用 B类中 - private
		 */
		person.sayPublic();
		person.say();
	}
}