老图搬砖day02——Java面向对象编程

8月11日

1）Java面向对象编程

2）Java常用工具类的使用

2.1 类和对象
2.2 类的创建
2.3 类的优势
2.4 包
课后习题1
2.5 类的方法
2.6 变量作用域
2.7 使用构造器
2.8 继承和多态
2.9 getter 和 setter 访问器
2.10

2.1 类和对象

1、对象

“万物皆对象”

对象的特性——属性Attribute，每个对象的每个属性都拥有特定值
对象的行为方式——方法 Method

2、类
物以类聚—类是对象的类型
从对象中抽象abstract出“类”

3、类和对象的关系
类是对某一类事物的抽象描述，是抽象的、概念上的定义；而对象是实际存在的该类事物的每个个体，因而也称实例

2.2 类的创建

public class Person{
	String name;
	int age;
	char gender;
	
	//方法定义
	public void eat(){
		System.out.println("正在吃饭.....");
	}
    public String toString(){
    //特殊的方法 toString() 可以实现将对象以字符串的形式来表达.
        return "大家好，我叫"+name+"，今年"+age+"岁，性别"+gender;
    }
}


//主程序
public class TestPerson {
	//程序入口
	public static void main(String[] args){
		Person p = new Person();
		p.name="张三";
		p.age="20";
		p.gender="男";

        p.eat();
   		System.out.println(p.toString);//这里也可以是println(p),toString隐含调用
   }
}

展示如下：

2.3 类的优势

便于程序模拟现实世界中的实体
 用“类”表示实体的特征和行为
 隐藏细节
 对象的行为和属性被封装在类中，外界通过调用类的方法来获得，不需关注内部细节如何实现
 可重用
 可以通过类的模板，创建多个类的对象

2.4 包

包名命名原则

1）组织的域名倒置
com|cn|org.公司名.项目名.xxx.xxx
2）全小写
3）自定义包不能用java开始

使用不同包中的类时,必须先导入后才能使用 import

package com.hzau.sy.demo1;
import com.hzau.sy.demo2.person;

课后习题1

定义类 人(Human)，根据Human类创建如图所示对象，并输出对象信息

//新建package com.hzau.sy
//定义Human类如下
package com.hzau.sy;

public class Human {
	String name;
	String skill;
	
	public String toString(){
		return "姓名："+name+"，招式："+skill;
	}

}

//主程序如下
package com.hzau.sy;

public class demo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		Human h = new Human(); //调用构造器
		h.name="洪七公";
		h.skill="打狗棒法";
		

   		System.out.println(h);//这里也可以是println(p),toString隐含调用
   		
   		
   		Human g = new Human();
		g.name="郭靖";
		g.skill="降龙十八掌";
		

   		System.out.println(g);//这里也可以是println(p),toString隐含调用
   		
   		Human y = new Human();
		y.name="杨过";
		y.skill="黯然销魂掌";
		

   		System.out.println(y);//这里也可以是println(p),toString隐含调用
	}

}

运行结果如下：

2.5 类的方法

方法定义的四要素：
1）返回值类型
2）方法名称
3）参数列表
4）方法主体
方法调用：call
对象名.方法名（）；
\\\\

类的形式

类的无参方法；
类的带参方法：参数分为形式参数和实际参数；

//数组作为方法参数：

package com.array;

public class Test {
 	public int find_max(int[] arr){
 		int max = arr[10];
 		for (int i =1;i<arr.length;i++){
 			if (arr[i]>max){
 			max = arr[i];
 		}
 		for(int i=1; i<arr.length;i++){
 		   if(arr[i]>max){
 		   	 max =arr[i];
 		    }
 		}
 		arr[0]=999;
 		return max;
 		
		public static void main(String[] args) {
		int[] nums = new int[]{23,33,56,77,12,123,43};
		
		Test t = new Test();
		int m = t.find_max(nums);  //实参--数组名
		System.out.println("最大值为: "+m);
		System.out.println(nums[0]);
	}
}

2.6 变量作用域

全局变量&局部变量

2.7 使用构造域

——创建对象时，使用new运算符调用的方法

	public class person {
	String name;
	int age;
	String gender;

	//默认构造器（每个类中都默认有一个无参的构造器）
	public person(){
		System.out.println("Person()默认构造器执行了");
	}
	
	//带参构造器（一个类中出现多个带参构造器，这就是出现重载）
	//当类中只定义了带参构造器，没有定义默认构造器，则不能在其他类中调用默认构造器）
	//为了使用方便，如果需要定义带参构造器，最好同时定义默认构造器
	public person(String name,int age){
		this.name = name ; //全局变量和部分变量同名，必须要加this.name（this泛指本类的某个对象）
		this.age = age;
		System.out.println("执行的是这个构造器");
	}
	//方法定义
	public void eat(){
		System.out.println("正在吃饭.....");
	}
    public String toString(){
    //特殊的方法 toString() 可以实现将对象以字符串的形式来表达.
        return "大家好，我叫"+name+"，今年"+age+"岁，性别"+gender;
    }
}

2.8 继承和多态

理解Java中的继承特点:

1. 单根继承—每个类有且仅有一个直接父类 ,间接父类
2. 所有java中的类都直接或间接继承自 java.lang.Object类
3. 继承关系的判断  is {子类} 而不是 has [属性]
4. 子类继承了父类的属性和方法 —实现代码重用

继承的实现

class Person {
	String name;
	int age;
	public void eat(){
		System.out.println(name+"在吃。。。。");
	}
}	
//extends ——扩展
class Student extends Person(){
	int sno;
	public void study(){
		System.out.println(name+"正在学习。。。");
	}
}

访问修饰符

public
protected
default
private

2.9 getter和setter访问器

在实际项目开发中，采用JavaEE开发模式，基于组件{JavaBean}的开发模式

public class Person {
    private String name;
	private int age;
	
	public String getName(){
		return this.name;
	}
	
	public void setName(String name){
		this.name = name;
	}
	
	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public void eat(){
		System.out.println(name+"正在吃....");
	}
}

2.11 super，this关键字

this—— 指向本类

1. 用于表示本类的某个对象
2. 用于调用本类的构造器
3. 用于调用本类的构造器

super——指向所在类的直接父类

public class Student extends Person{
	int sno;
	
	public Student(){
		super("李四",21);
		System.out.println("Student()默认构造器执行了...");
	}
	
	public Student(int sno,String name,int age){
		super(name,age);  //调用父类被重载的构造器
		this.sno = sno;
		System.out.println("Student(int)带参构造器执行了....");
	}
}