Java编程之面向对象

一.面向对象

1.定义

（1）类：描述的是具有共性的一类事物

（2）对象：一个个具备了类的特点和功能的个体

（3）面向对象：要完成某件事，首先要先有对象，然后直接调用这个对象的响应功能

2.成员变量：写在方法之外的全局变量

public int publicField;         //公共，任何人都可以使用
private int privateField;       //私有，一般指定给与子类使用
protected int protectedField;   //受保护，一般指定给子类使用，只要是子类都能使用，不是子类同包下可以访问
int defaultField;               //默认修饰符，只能同包下访问
public void hishigh(){
    System.out.println(defaultField);        //在方法里面引入成员变量
}

3.局部变量

public void he(String name){        //方法中引入可变的成员变量
    System.out.println("他的名字叫"+name);
}
public void from(){
    String palce="上海";            //局部变量
    System.out.println(palce);
    }

4.return：把结果返回給调用者

public String end(){    //使用void不能返回结果，使用数据类型可返回相应数据类型的结果
    return "结果";
}

5.方法重载：方法名相同，传入的变量不同，构造方法也可以重载

public void student(){
        System.out.println("男生一共有："+boy);       //boy用的是成员变量里的boy
    }
    public void student(int girl){
        System.out.println("女生一共有："+girl);
    }

6.static

static int boy;
int girl;
String name;
public void studentname(){      //只能创建对象后调用方法
        System.out.println("学生的名字："+name);      //使用的是全局变量
    }
public static void student(){      //可直接调用方法，也可以创建对象调用方法
        System.out.println("男学生一共"+boy);    //使用的是全局变量，方法中加了static，因此在全局变量中也要加static。
    }
    public static void student(int girl){
        System.out.println("女学生一共"+girl);    //使用的是方法引入的局部变量，而不是全局变量
    }
public static void main(String[] args){
    Student mystudent=new Student();    //运行这一行结果是构造函数方法中的内容，new Student调用了类中的构造方法
    mystudent.studentname();
    student();
    mystudent.student();
}

7.get/set：私有全局变量可通过设置和获取来返回給全局变量

private int privateField;       //private私有，只能本类访问，要在对象中给成员变量赋值，可通过set：this.age=age，再用get获取成员变量的值
public void setPrivateField(int privateField) {    //设置私有参数值，因为创建对象不能直接給私有变量赋值，需要用set方法赋值然后传递給私有变量
    this.privateField = privateField;
}
public int getPrivateField() {          //获取set方法设置的值返回结果給get方法，用get方法主要是在创建对象中需要用get+私有变量名替代私有变量名
    return privateField;
}
public static void main(String[] args){
    Animals animals=new Animals();
    animals.setPrivateField(10);     //设置set局部变量的值，当不符合条件是将值赋给成员变量
    System.out.println(animals.getPrivateField());   //获取到了成员变量的值并返回给get，如果用void不能返回值，需要在对象中写私有成员变量，但是私有变量在本类以外不能访问
}

8.空参构造/有参构造/构造方法重载

构造方法，可以写可以不写，如果一个类没有写任何的构造方法，Java会提供一个没有参数的构造方法。如果写了构造方法，Java不再提供，构造方法可以为空参可以有参。在一个class中，构造方法可以重载

Student.class
public Student(){                              //空参构造：写了构造方法，但是构造方法里没有参数
    System.out.println("空参构造函数方法");
}
//构造方法可以重载。有参构造：里面的参数如果是用来定义成员变量的值，需要将有参构造的值赋给成员变量
public Student(int a,int boy){                   //Java中查找变量有就近原则，先从方法内部找，再到类中找，所以如果局部变量和成员变量的变量名相同，用this区分。
    girl=a;                                      //成员变量名和局部变量名不同，成员变量可不加this。将构造方法中引入的变量值引入后赋给成员变量
    this.boy=boy;                                //this关键字用来区分成员变量和局部变量，加this的变量是成员变量。查找的范围最小时的本类，this代表当前对象
}
public static void main(String[] args){
    Student mystudent1=new Student();            //运行这一行结果是构造函数方法中的内容，new Student调用了类中的构造方法
    Student mystudent2=new Student(3,4);         //构造方法可以重载
}

二.三大特性

1.封装

将代码通过函数的形式包装起来，然后直接调用

Student.class
public void studentgirl(){                 //没有加static，只能通过创建对象来调用方法
    System.out.println("女学生一共有："+girl);
}
public static void studentage(int age){    //有static，可以创建对象调用或直接调用
    System.out.println("学生的平均年龄："+age);
}
public static void main(String[] args){    //创建对象可在同一个class下，也可以在新的class下创建
    Student mystudent1=new Student();      //运行这一行结果是构造函数方法中的内容，new Student调用了类中的构造方法
    Student mystudent2=new Student(3,4);   //构造方法可以重载
    System.out.println(mystudent1);        //地址值
    System.out.println(mystudent2);        //对象的地址值，new+类相当于新创建了一个地址
    mystudent2.studentgirl();
    mystudent2.studentage(5);              //通过创建对象调用static方法
    studentage(5);                         //直接调用static方法
}

2.继承

（1）方法重写

public class IphoneTest extends Iphone{    //继承Iphone父类
    @Override             //注解一段功能，检查此方法是否为一个重写的方法
    public void siri(){      //方法重写，siri是Iphone父类中的方法，在子类中重写
        super.siri();        //super最小查找范围是父类，父类中的siri方法
        call();                //父类中的方法
    }

（2）子类特有的方法

看不到子类特有的方法，因为子类有很多个，如果要使用子类特有的方法，需要强制类型转换

public class StudentTest extends Student {
    public void test(){
        System.out.println("子类自己的方法");
    }
    public static void main(String[] args){
        StudentTest st=new StudentTest();
        StudentTest stest=(StudentTest) st;       //向下强制转型，才可以使用子类特有的方法
        stest.test5();                            //向下强制转型后，使用子类特有的方法
    }

（3）子类的方法构造

public InterageDomo(){
    //super("scarlett");            //调用父类的构造，如果父类中有有参构造没有空参构造，就必须在括号里加参数，如果父类中只有空参构造，括号内为空
    this("scarlett");               //如果本类中有构造函数，可以使用this调用本类的构造。super和this只能使用一个，并且是在构造的第一行。如果本类中没有构造函数，则不使用this
}
public InterageDomo(String name){   //本类的构造函数
    this.name=name;
}

3.多态

（1）父类的类型接受子类的对象；（2）用多态创建只需一个父类变量就能接收所有子类对象

//Student为父类，StudentTest和InterageDomo为子类
Student st=new StudentTest();         //多态：父类的类型接受子类的对象，向上转型，用多态创建的优势：只需一个父类变量就能接收所有子类对象
System.out.println(st);               //StudentTest子类对象的地址
st=new InterageDomo("scarlett");      //用多态创建的优势：只需一个父类变量就能接收所有子类对象
System.out.println(st);               //InterageDomo子类对象的地址