day08 面向对象（上）a

一.面向对象的三条主线

1.java类以及类的成员：属性，方法，构造器，代码块，内部类

2.面向对象的三大特征：封装性，继承性，多态性，（抽象性）

3.其他关键字：this, super, static, final, abstract, interface, package, import等

面向对象（重对象（具有功能的），谁去做）与面向过程（重函数，怎么做）

例如：

“人把大象装进冰箱”

面向过程：

1.打开冰箱门

2.抬起大象，装进冰箱

3.关闭冰箱门

面向对象：

找主体封装成类，再实例化对象：

人

{

打开（冰箱）

　　{

　　冰箱.开开（）；　　

　　}

抬起（大象）

　　{

　　大象.进入（冰箱）；　　

　　}

关闭（冰箱）

　　{

　　冰箱.闭合（）；

　　}

}

冰箱

{

　　开开.();

　　闭合();

}

大象

{

进入（冰箱）；

}

然后创造一个真实的人,真实的冰箱，真实的大象，进行操作。（从面向过程的执行者，到了面向对象的指挥者）

类：对一类事物的描述，抽象、概念上的定义

对象：是实际存在的该类事物的每个个体，也被成为实例

联系：类中有的功能，对象才有

 一.类具备属性与行为（方法）

类和对象的具体使用：

1.创建类，设置类成员，类方法

2.创建类的对象

3.通过“类.属性”或“类.方法”调用对象的结构

//Test class
public class PersonTest {
public static void main(String[] args) {
//create calss Person's object
    Person person=new Person();
    person.name="Tom";
    person.isMale=true;
    person.eat();
    person.talk("English");
}
}

class Person
{
    //field
        String name;
        int age=1;
        boolean isMale;
    //method
        public void eat()
        {
            System.out.println("People can eat!");
            
        }
        public void talk(String language) 
        {
            System.out.println("People can talk using:"+language);
        }
}

 一个类的不同对象：

以下包括两种情况：1.同一个类下的不同对象拥有不同属性；2.同一个类下的对象相等（=）是赋地址值

 

//Test class
public class PersonTest {
public static void main(String[] args) {
//create calss Person's object
    Person person1=new Person();
    person1.name="Tom";
    person1.isMale=true;
    System.out.println(person1.name);
    person1.eat();
    person1.talk("English");
    //不同对对象拥有不同属性
    Person person2=new Person();
    System.out.println(person2.name);
    //对象之间=，则赋的是地址值
    Person person3=new Person();
    person3=person1;
    System.out.println(person3.name);
    person3.name="Jake";
    System.out.println(person1.name);
}
}

class Person
{
    //field
        String name;
        int age=1;
        boolean isMale;
    //method
        public void eat()
        {
            System.out.println("People can eat!");
            
        }
        public void talk(String language) 
        {
            System.out.println("People can talk using:"+language);
        }
}

结果显示：

 

对象创建中的内存

 

 

 

 其中，方法区存储已经加载的类信息，常量，静态变量，即时编译后的代码

 

 

 注意：类中的属性不是局部变量（是成员变量），应该存在堆区

局部变量与属性（成员变量）对比

 

 

 

 

 

 

 

 

 

 

 局部变量不可以使用权限修饰符，其权限为所属方法的权限

方法：

 

 

 主要就是要不要传进去，有没有返回，而且一定是有权限修饰符的

方法使用：

可以调用当前类的属性和方法，特别地，方法A中调用方法A为递归调用，但是容易出现死循环（栈溢出）

方法中不可以定义别的方法

需要注意的：调用类中的方法时，不一定给方法传行参，而是改变类中的属性（不能又给属性，又传入相同意义的形参）。例如：

 

 

 

 这里有属性半径radius，算面积时用的又是r，改为

 

 

 

 

 

 对象数组的使用

public class StudentTest {
public static void main(String[] args) {
    Student[] stus=new Student[20];
    for(int i=0;i<stus.length;i++) {
        stus[i]=new Student();//必须还要给数组中的元素一个对象
        stus[i].number=i+1;
        //年级为[1,6]
        stus[i].state=(int)(Math.random()*(6-1+1)+1);
        //分数为[0,100]
        stus[i].score=(int)(Math.random()*(100-0+1));}
    StudentTest test=new StudentTest();
    
        //遍历
        test.print(stus);
    
        //排序
        test.sort(stus);
    System.out.println("***************************");
    test.print(stus);
}
//将功能封装
//遍历学生数组
public void print(Student[] stus) {
    for(int i=0;i<stus.length;i++)
    {
        System.out.println(stus[i].info());
    }
}
//使用冒泡对成绩从小到大排序
public void sort(Student[] stus) {
for(int i=0;i<stus.length;i++)
{
    for(int j=0;j<stus.length-1-i;j++)
    {
        if(stus[j].score>stus[j+1].score)
        {
            Student temp=new Student();
            temp=stus[j+1];
            stus[j+1]=stus[j];
            stus[j]=temp;
            
        }
    }
}
}
}
class Student {
    int number;
    int state;
    int score;
    //显示学生信息
    public String info(){
        return "学号："+number+"年级："+state+"成绩："+score;
    }

}

其中，涉及到：

1.对象数组创建后，里面的元素就是数组对象，也要new

2.方法可以进行封装