自学Java第五章——《面向对象基础》
5.1 类与对象
1、类：一类具有相同特性的事物的抽象描述。
对象：类的一个个体，实例，具体的存在。
类是对象的设计模板。
2、如何声明类？
【修饰符】 class 类名{
成员列表：属性、方法、构造器、代码块、内部类
}
3、如何创建对象？
new 类名(); //匿名对象
类名 对象名 = new 类名(); //有名对象
5.2 类的成员之一：属性
1、如何声明属性？
【修饰符】 class 类名{
【修饰符】 数据类型 属性名; //属性有默认值
【修饰符】 数据类型 属性名 = 值; //属性有初始值
}
说明：属性的类型可以是Java的任意类型，包括基本数据类型、引用数据类型（类、接口、数组等）
总结：Java的数据类型
（1）基本数据类型
byte,short,int,long,float,double,char,boolean
（2）引用数据类型
①类：
例如：String、Student、Circle、System、Scanner、Math...
②接口：后面讲
③数组：
例如：int[]，String[]，char[]，int[][]
int[] arr = new int[5];
这里把int[]看成数组类型，是一种引用数据类型，右边赋值的是一个数组的对象
元素的数据类型：int
数组的数据类型：int[]
2、如何为属性赋值？
（1）在声明属性时显式赋值
【修饰符】 class 类名{
【修饰符】 数据类型 属性名 = 值; //属性有初始值
}
代码示例：
class Student{
String name;
char gender = '男';//显式赋值
}
class TestStudent{
public static void main(String[] args){
Student s1 = new Student();
System.out.println("姓名：" + s1.name);//null
System.out.println("性别：" + s1.gender);//男
s1.name = "小薇";//修改属性的默认值
s1.gender = '女';//修改属性的初始值
System.out.println("姓名：" + s1.name);//小薇
System.out.println("性别：" + s1.gender);//女
Student s2 = new Student();
System.out.println("姓名：" + s2.name);//null
System.out.println("性别：" + s2.gender);//男
}
}
（2）创建对象之后赋值
【修饰符】 class 类名{
【修饰符】 数据类型 属性名; //属性有默认值
}
//创建对象
类名 对象名 = new 类名();
//为对象的属性赋值
对象名.属性名 = 值;
3、如何访问属性的值？
（1）在本类的方法中访问
示例代码：
class Circle{
double radius;
double getArea(){
return 3.14 * radius * radius;//直接访问
}
}
（2）在其他类的方法中访问
class Circle{
double radius;
}
class TestCircle{
public static void main(String[] args){
Circle c1 = new Circle();
double area = 3.14 * c1.radius * c1.radius;//对象名.属性名
}
}
4、属性的特点
（1）属性有默认值
基本数据类型：
byte,short,int,long：0
float，double：0.0
char：\u0000
boolean：false
引用数据类型：
null
（2）每一个对象的属性是独立，互不干扰
5、对象属性的内存图
class Student{
String name;
char gender = '男';//显式赋值
}
class TestStudent{
public static void main(String[] args){
Student s1 = new Student();
System.out.println("姓名：" + s1.name);//null
System.out.println("性别：" + s1.gender);//男
s1.name = "小薇";
s1.gender = '女';
System.out.println("姓名：" + s1.name);//小薇
System.out.println("性别：" + s1.gender);//女
Student s2 = new Student();
System.out.println("姓名：" + s2.name);//null
System.out.println("性别：" + s2.gender);//男
}
}
5.4 类的成员之二：方法
5.4.1 方法的概念
方法（method）：代表一个独立的可复用的功能
目的/好处：
（1）复用
（2）简化代码
5.4.2 方法的语法
1、方法的声明格式：
【修饰符】 class 类名{
【修饰符】 返回值类型 方法名(【形参列表】){
方法体：实现功能的代码
}
}
说明：
（1）【修饰符】：待讲
（2）返回值类型：
①void：表示无返回值
②非void：所有的Java数据类型都可以
（3）方法名：能很好的体现方法的功能
命名的规范：①见名知意②从第二个单词开始首字母大写
（4）【形参列表】：
在完成这个方法的功能时，需要一些数据，这些数据要由“调用者”来决定，那我们就可以设计形参。
语法格式：
()：无参，空参
(数据类型 形参名)：一个形参
(数据类型1 形参名1, ......, 数据类型n 形参名n)：n个形参
（5）方法体：实现方法的功能，最好一个方法就完成一个独立的功能。
2、方法的调用格式：
//本类同级别方法调用：直接调用
【变量 = 】 方法名(【实参列表】);
//在其他类的方法中调用
【变量 = 】 对象名.方法名(【实参列表】);
（1）是否传实参
看被调用的方法是否有形参
（2）是否接收返回值
看被调用的方法是否是void，如果是void，就不需要也不能接收，如果不是void，就可以接收。
3、方法的声明与调用的代码示例
（1）无参无返回值方法
//本类
class Circle{
double radius;
void printInfo(){
System.out.println("半径：" + radius);
}
void test(){
printInfo();//本类中调用无参无返回值方法
}
}
//其他类
class Circle{
double radius;
void printInfo(){
System.out.println("半径：" + radius);
}
}
class TestCircle{
public static void main(String[] args){
Circle c1 = new Circle();
c1.printInfo(); //其他类中调用无参无返回值方法
}
}
（2）无参有返回值方法
//本类
class Circle{
double radius;
double getArea(){
return 3.14 * radius * radius();
}
void printInfo(){
// System.out.println("半径：" + radius + "，面积：" + getArea());//本类中调用无参有返回值
double area = getArea();//本类中调用无参有返回值
System.out.println("半径：" + radius + "，面积：" + area);
}
}
//其他类
class Circle{
double radius;
double getArea(){
return 3.14 * radius * radius();
}
}
class TestCircle{
public static void main(String[] args){
Circle c1 = new Circle();
double area = c1.getArea();
System.out.println("面积：" + area);
//或
System.out.println("面积：" + c1.getArea());
}
}
（3）有参无返回值方法
//本类
class GraphicTools{
void printRectange(int line, int column, char sign){
for(int i=1; i<=line; i++){
for(int j=1; j<=column; j++){
Sytem.out.print(sign);
}
System.out.println();
}
}
void test(){
printRectange(5,10,'%');//本类中调用有参无返回值方法
}
}
//其他类
class GraphicTools{
void printRectange(int line, int column, char sign){
for(int i=1; i<=line; i++){
for(int j=1; j<=column; j++){
Sytem.out.print(sign);
}
System.out.println();
}
}
}
class Test{
public static void main(String[] args){
GraphicTools tools = new GraphicTools();
tools.printRectange(5,10,'%');
}
}
（4）有参有返回值方法
//本类
class MyMath{
int sum(int a,int b){
return a+b;
}
void print(){
int x = 4;
int y = 7;
System.out.println(x + "+" + y + "=" + sum(x,y);//本类中调用有参有返回值的方法
}
}
//其他类
class MyMath{
int sum(int a,int b){
return a+b;
}
}
class Test{
public static void main(String[] args){
MyMath my = new MyMath();
int x = 4;
int y = 7;
System.out.println(x + "+" + y + "=" + my.sum(x,y));
}
}
4、方法声明与调用的原则
（1）方法必须先声明后调用
如果调用方法时，如果方法名写错或调用一个不存在的方法，编译会报错
（2）方法声明的位置必须在类中方法外
正确示例：
类{
方法1(){
}
方法2(){
}
}
错误示例：
类{
方法1(){
方法2(){ //错误
}
}
}
（3）方法的调用的位置有要求
正确示例：
类{
方法1(){
调用方法
}
}
错误示例：
类{
方法1(){
}
调用方法 //错误位置
}
（4）方法的调用格式要与方法的声明格式对应
①是否要加“对象.”：看是否在本类中，还是其他类中
②是否要接收返回值：看被调用方法是否是void
③是否要传实参：看被调用方法是有形参列表
5.4.3 方法的重载Overload
概念：在同一个类中，出现了两个或多个的方法，它们的方法名称相同，形参列表不同，这样的形式称为方法的重载。和返回值类型无关。
示例代码：
//求两个整数的最大值
public int max(int a,int b){
return a>b?a:b;
}
//求三个整数的最大值
public int max(int a, int b, int c){
return max(max(a,b),c);
}
//求两个小数的最大值
public double max(double a, double b){
return a>b?a:b;
}
5.4.4 方法的参数传递机制
Java中方法的参数传递机制：值传递
（1）形参是基本数据类型时，实参给形参传递数据值，是copy的形式，形参对值的修改不影响实参。 （2）形参是引用数据类型时，实参给形参传递地址值，形参对对象的属性的修改，会影响实参对象的属性值，因为此时形参和实参就是指向同一个对象。 示例代码：
class Test{
public static void swap(int a, int b){
int temp = a;
a = b;
b = temp;
}
public static void main（String[] args){
int x = 1;
int y = 2;
swap(x,y);//调用完之后，x与y的值不变
}
}
示例代码：
class Test{
public static void change(MyData my){
my.num *= 2;
}
public static void main(String[] args){
MyData m = new MyData();
m.num = 1;
change(m);//调用完之后，m对象的num属性值就变为2
}
}
class MyData{
int num;
}
陷阱1：
/*
陷阱1：在方法中，形参 = 新new对象，那么就和实参无关了
*/
class Test{
public static void change(MyData my){
my = new MyData();//形参指向了新对象
my.num *= 2;
}
public static void main(String[] args){
MyData m = new MyData();
m.num = 1;
change(m);//调用完之后，m对象的num属性值仍然为1
}
}
class MyData{
int num;
}
陷阱2：见字符串和包装类部分
5.4.5 可变参数的练习
public class srudy {
public static void main(String[] arge) {
MyMath my =new MyMath();
System.out.println("拼接是"+my.con("我是","你","爸爸"));
System.out.println("5的阶乘是"+ my.mutiply(1,2,3,4,5));
}
}
class MyMath{
String con(String...args) {
String str ="";
for(int i=0;i<args.length;i++) {
str+=args[i];
}
return str;
}
long mutiply(int a,int...num) {
long result=a;
for(int i=0;i<num.length;i++) {
result*=num[i];
}
return result;
}
}
5.4.6 成员变量与局部变量
1、成员变量：
2、局部变量：
（1）初始化不同
（2）生命周期不同
（3）位置不同
①成员变量在堆中 ②局部变量在栈中
（4）声明的位置不同
①成员变量在类的方法之外 ②局部变量在类的方法之内
5.3 对象数组
一维数组：
1、元素是基本数据类型
2、元素是引用数据类型，也称为对象数组，即数组的元素是对象
注意：对象数组，首先要创建数组对象本身，即确定数组的长度，然后再创建每一个元素对象，如果不创建，数组的元素的默认值就是null，所以很容易出现空指针异常NullPointerException。
示例代码：
class MyDate{
int year;
int month;
int day;
}
class Test{
public static void main(String[] args){
MyDate[] arr = new MyDate[3];//创建数组对象本身，指定数组的长度
for(int i=0; i<arr.length; i++){
arr[i] = new MyDate();//每一个元素要创建对象
arr[i].year = 1990 + i;
arr[i].month = 1 + i;
arr[i].day = 1 + i;
}
}
}
public class srudy {
public static void main(String[] arge) {
circle[] arr =new circle[5];
for(int i=0;i<arr.length;i++) {
arr[i]=new circle();
arr[i].R=i+1;
arr[i].py();
}
}
}
class circle{
double R;
double getArea() {
return 3.14*R*R;
}
void py() {
System.out.println("半径是："+ R +" 面积："+getArea());
}
}
练习
package study; public class srudy { public static void main(String[] arge) { java.util.Scanner input=new java.util.Scanner(System.in); Student[] arr=new Student[3]; for(int i=0;i<arr.length;i++) { System.out.print("请输入"+(i+1)+"成员的信息"); arr[i]=new Student(); System.out.print("姓名："); arr[i].name=input.next(); System.out.print("成绩："); arr[i].score=input.nextInt(); } for(int i=0;i<arr.length;i++) { arr[i].printInfo(); } System.out.println("----------------------------"); for(int i=0;i<arr.length;i++) { //第二种方式 System.out.println(arr[i].pr()); } } } class Student{ String name; int score; void printInfo(){ System.out.println("姓名"+name+" 成绩："+score); } String pr(){ return "姓名"+name+" 成绩："+score; } }
