javaBasics篇（七）面向对象编程

面向对象编程

一、方法

//格式：
    /* 修饰符 返回值类型 方法名（参数）{
           方法体；
           return 返回值
}

注意：方法的返回值类型为void时，方法可以不用返回具体的值。

方法可以分为：（1）静态方法 用static关键字修饰的。
静态方法调用时，直接通过类名.方法名调用
（2）非静态方法 没有用static修饰的方法。
非静态方法调用时则需要实例化对象，然后通过对象来调用这个方法（其实就是new一个对象）

public class demo01 {

    public static void main(String[] args) {

        //实例化对象 调用非静态方法
         Name name = new  Name();
         name.eat();

         //直接通过类名调用静态方法
        Name.eats();

    }

}

public class Name {

    //非静态方法
    public void eat(){
        System.out.println("干饭人起来干饭啦！！！！");
    }


    //静态方法 可以直接通过类名.方法名调用
    public static void eats(){
        System.out.println("干饭人起来干饭啦！！！！");
    }
}

二、构造器
构造器：和类名相同但是没有返回类型的方法。
new了一个对象，这个对象必须有无参构造。
构造器是不能被继承的，所以不可以进行重写（override）的，但可以进行重载（overload）

public class Person {


     String name;

    //用来初始化值
    //使用new实例化对象，实质上是调用构造器
    public Person() {
    }

    //有参构造，一旦有了有参构造，无参构造就必须显示定义
    public Person(String name) {
        this.name=name;
    }
}

public class demo01 {

    public static void main(String[] args) {

        //new实例化对象
        Person person = new Person("干饭人");
        System.out.println(person.name);



    }

}

三、面向对象的三大特征
3.1封装

public class school {

//属性私有
    private double area;
    private String name;
    private int  teacher;
//get set方法封装
    public double getArea() {
        return area;
    }

    public void setArea(double area) {
        this.area=area;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getTeacher() {
        return teacher;
    }

    public void setTeacher(int teacher) {
        this.teacher = teacher;
    }
}

public class demo01 {

    public static void main(String[] args) {
   school sch=new school();
   sch.setName("青岛理工大学");
   sch.setArea(2654.897);
   sch.setTeacher(2356);

   System.out.println
           ("学校名称："+sch.getName()+"占地面积为："+sch .getArea()+"平方千米"+","+"师资力量："+sch.getTeacher()+"人");


    }

}

封装的作用：
（1） 提高程序的安全性和可维护性。
（2）隐藏类的实现细节
（3）统一接口

3.2继承

3.2.1super关键字

public class Average extends Sum {//子类继承父类
     int n;//成员变量
     float f(){//方法
    	 float c;
    	 super.n = n;//super关键字调用子类继承所隐藏的成员变量
    	 c = super.f();//用对象名调用父类的f方法
    	 return  c/n;
     }
     float g(){
    	 float c;//局部变量声明
    	 c = super.f();//也是调用父类的f方法但是此时没有用到n
    	 return  c/2;
     }
}
public class Sum {
   int n;
   float f(){
   float sum = 0;
   for(int i = 1;i<=n;i++)//for循环 先进行判断满足执行循环代码，然后才是加一 n = 100 执行了100次
	   sum = sum+i;//循环代码1+2+3+  + +99=  n（a1+an）/2
   return sum;
   }
}
public class Example {
  public static void main(String args[]){
	  Average aver = new Average();//创建对象执行的时候先跳到Average类中
	  aver.n = 100;//赋值 n = 100
	  float resultOne = aver.f();//调用方法
	  float resultTwe = aver.g();
	  System.out.println("resultOne="+resultOne);//输出
	  System.out.println("resultTwe="+resultTwe);
  }
}

3.2.2重写

注意的点：
（1）声明为final，static的方法不能被重写，但是static声明的方法可以被再次声明。
（2）构造方法不能被重写
（3）重写的前提是继承
（4）如果父类和子类都在同一个包里，子类可以重写父类的非private、final之外的所有方法，如果不在同一包里，则只能重写public修饰的方法。

3.3多态
多态：同一接口，使用不同的实例执行的结果。
作用：（1）消除类型之间的耦合关系
（2）可替换性、可扩充性、接口性、灵活性、简化性
实现多态的前提条件：(1)要有继承
（2）要有方法的重写
（3）父类引用指向子类对象

例子：父类：public class HttpServlet {
	public void service() {
		System.out.println("HttpServlet - service");
		doGet();
	}
	public void doGet() {
		System.out.print("HttpServlet - doGet");
	}
 }
子类：public class MyServlet extends HttpServlet {
 public void doGet() {
		System.out.println("MyServlet -  do Get");
	}
}
主类：public class Test {
 public static void main(String[] args) {
		HttpServlet s = new MyServlet();
s.service();
	}
 }
//结果：HttpServlet - service
MyServlet -  do Get
//代码分析：HttpServlet s = new MyServlet();
// s 虽然是父类变量的引用，但是指向的是子类对象。  s.service();// 子类中没有定service，因此调用的是继承父类的service方法，然后service方法中调doGet，这时候也是以子类中优先查找重写的doGet方法。

3.3.1向上转型、向下转型
（1）向上转型
子类对象赋值给父类引用(减少代码重复)
格式： 父类类型 变量名 = new 子类类型（） Father f = new son()
Person p = new Student();
（2）向下转型
已经向上转型的子类可以使用强制类型转换格式，将父类对象赋值给子类引用
格式：子类类型 变量名 = （子类类型）父类类型变量名
son s = (son)f

3.3.2重写和重载的区别？
重载（overload）：一个类中可以有多个方法具有相同的名字，但这些方法的参数必须不同（参数个数不同。 参数个数相同但参数表对应某个参数的类型不同。）
（1）重写和重载都是java多态性的不同表现
（2）重写是子类与父类之间多态性的一种表现，重载是一个类中多态性的表现。