java 面向对象 2

1.java 中三种方法的调用

1.1.普通类：实例化一个该类的对象，然后通过对象访问。例如：

 public  classs A{//实例方法（成员方法）
          public void method 1(){
                   System.out.println("我是A类的方法1");
          }
}
public static void main(String[] args){
          A a=new A();//实例化一个对象
          a.method1();
}

1.2、静态类：可以通过类名直接访问，而不用实例化对象。例如：

public  class static A{//类方法（静态方法）
         public static void method1(){
                    System.out.pringtln("我是A类的方法1")
         }
}
public static void main(String[] args){
          A.method 1 ();//静态方法的调用：类名.方法名
}
1.3构造方法的调用

public class A{
   public A(){
      System.out.println("调用了无参的构造函数");
   }
   public A(String mess){
      System.out.println("调用了有参的构造函数\n"+
         "参数内容为："+mess);
   }
}

 Test.java

public class Test{
   public static void main(String [] args){
       A a_1=new A();//调用无参的构造函数
       A a_2=new A("Hello");//调用有参的构造函数
   }
}

下面是三种方法调用的实例：

public class Trangle {
    static double a;
    static double b;
    static double c;
    static double p;

    int Tra;

    public Trangle() {

    }

    // 计算任意三点组成的三角形面积（使用三种方法计算）
    Trangle(Point p1, Point p2, Point p3) {

        a = Math.sqrt((p2.y - p1.y) * (p2.y - p1.y) + (p2.x - p1.x) * (p2.x - p1.x));
        b = Math.sqrt((p3.y - p2.y) * (p3.y - p2.y) + (p3.x - p2.x) * (p3.x - p2.x));
        c = Math.sqrt((p3.y - p1.y) * (p3.y - p1.y) + (p3.x - p1.x) * (p3.x - p1.x));
        p = (a + b + c) / 2;

        Tra = (int) Math.sqrt(p * (p - a) * (p - b) * (p - c));
    }

    public static int Tra1(double p, double a, double b, double c) {

        return (int) Math.sqrt(p * (p - a) * (p - b) * (p - c));
    }

    public int Tra2(double p, double a, double b, double c) {
        return (int) Math.sqrt(p * (p - a) * (p - b) * (p - c));
    }

    public static void main(String[] args) {
        Point p1 = new Point(2, 2);
        Point p2 = new Point(7, 8);
        Point p3 = new Point(39, 0);

        Trangle t = new Trangle(p1, p2, p3);
        System.out.println("构造方法计算，三角形的面积是：" + t.Tra);

        Trangle t1 = new Trangle();
        int s1 = t1.Tra2(p, a, b, c);

        System.out.println("对象方法计算，三角形的面积是：" + s1);

        int s2 = Trangle.Tra1(p, a, b, c);
        System.out.println("类方法计算，三角形的面积是：" + s2);

    }

}

 2.java 面向对象之继承

2.1、  什么是继承，继承的特点？

子类继承父类的特征和行为，使得子类具有父类的各种属性和方法。或子类从父类继承方法，使得子类具有父类相同的行为。

2.2继承的特点：

（1）在继承关系中，父类更通用、子类更具体。父类具有更一般的特征和行为，而子类除了具有父类的特征和行为，还具有一些自己特殊的特征和行为。

（2）在继承关系中。父类和子类需要满足is-a的关系。子类是父类。

（3）表示父类和子类的术语：父类和子类、超类和子类、基类和派生类，他们表示的是同一个意思。

（4）覆盖（重写）

（5）如果子父类中的成员一致时，子类成员会覆盖父类成员

（6）当子类继承父类时，沿袭父类的功能到子类中，但子类对该功能的实现细节不一致，子类可以保留父类对该功能的定义，重写功能的内容

（7）覆盖与重载：重载只看参数列表，其他一致参数列表不一致为重载，而重写子父类的参数必须要一致

（8） this与super

this表示当前对象的引用，super表示当前对象父类的引用

2。3、  为什么需要继承？什么时候应该继承？

使用继承可以有效实现代码复用，避免重复代码的出现。

当两个类具有相同的特征（属性）和行为（方法）时，可以将相同的部分抽取出来放到一个类中作为父类，其它两个类继承这个父类。

继承实现了面向对象的原则：write once,only once（编写一次、且编写一次

2.4  如何实现继承？

在Java语言中，用extends（扩展）关键字来表示一个类继承了另一个类。

在父类中只定义一些通用的属性和方法。

子类自动继承父类的属性和方法，子类中可以定义特定的属性和方法。或子类重新定义父类的属性、重写父类的方法可以获得与父类不同的功能。

2.5继承的作用

（1）父类具备的方法子类可以直接继承过来，不用重新书写，提高了代码的复用性

（2）让类与类之间产生关系，有了关系才有多态的实现

（3）Java中只支持单继承，不支持多继承，因为多继承存在安全隐患（当多个父类存在同个功能时，子类不确定要运行哪一个），Java支持多层继承，即父类还可以继承其他类，java用另一种机制解决单继承的局限性，即多实现

2.5子父类中的构造函数

（1）构造函数不能重写

（2）构造函数第一行有一条隐式的语句super()/this()

（3）在对子类对象进行初始化时，父类构造函数也会运行，因为子类中的构造函数默认第一行有一条隐式的super()语句，这样方便子类构造时先获取到父类的共性属性

（4）super()一定要定义在子类构造函数的第一行，当没有默认的空参数构造函数，要手动指定

2.6、  什么是方法重写？

如果在子类中定义的一个方法，其名称、返回类型及参数列表正好与父类中某个方法的名称、返回类型及参数列表相匹配，那么可以说，子类的方法重写了父类的方法。

方法重写在不同类，是实现多态的必要条件。

2.6.1代码实现重写

public class Father{

   public void speak(){

       System.out.println(Father);

    }

}

public class Son extends Father{

    public void speak(){

        System.out.println("son");

   }

}

这也叫做多态性，重写方法只能存在于具有继承关系中，重写方法只能重写父类非私有的方法

2.6.2重写方法的规则：

（1）参数列表必须完全与被重写的方法相同，否则不能称其为重写而是重载。

（2）返回的类型必须一直与被重写的方法的返回类型相同，否则不能称其为重写而是重载。

（3）访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private）

（5）重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常。例如：

父类的一个方法申明了一个检查异常IOException，在重写这个方法是就不能抛出Exception,只能抛出IOException的子类异常，可以抛出非检查异常。

 2.7什么是方法的重栽

 方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在，具有不同的参数个数/类型。

重载Overloading是一个类中多态性的一种表现。

（2） Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。

调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性。

（3） 重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准。

2.7.1重载的规则：

1、必须具有不同的参数列表；

2、可以有不责骂的返回类型，只要参数列表不同就可以了；

3、可以有不同的访问修饰符；

4、可以抛出不同的异常；

2.7.2重栽的代码实现

  public class Dog {
         Dog()
         {
                this.bark();
         }
         void bark()//bark()方法是重载方法
         {
                System.out.println(\"no barking!\");
                this.bark(\"female\", 3.4);
         }
         void bark(String m,double l)//注意：重载的方法的返回值都是一样的，
         {
                System.out.println(\"a barking dog!\");
                this.bark(5, \"China\");
         }
         void bark(int a,String n)//不能以返回值区分重载方法，而只能以“参数类型”和“类名”来区分
         {
                System.out.println(\"a howling dog\");
         }

         public static void main(String[] args)
         {
                Dog dog = new Dog();
                //dog.bark(); [Page]
                //dog.bark(\"male\", \"yellow\");
                //dog.bark(5, \"China\");

 

2.7.3重写和重栽的区别

（1）方法的重写用在子类方法与父类方法一模一样时，除权限修饰符，返回值类型，方法名和参数列表都是相同的。
（2）重载用在同一个类中各方法方法名相同，参数列表不同（与返回值类型没有关系）的情况。

2.8 super关键字的用法和位置，super关键字调用父类的构造方法，super关键字调用父类的方法？

 

（1）在子类的构造方法中，通过super关键字调用父类的构造方法。

 

（2）如果子类中重写了父类的方法，可以通过super关键字调用父类的方法。

父类：
private String name;
private String sex;
public xinxin1(String name,String sex)
{
           this.name=name;
           this.sex=sex;
}
         public void hello(){
                   System.out.println(“嗨！我是”+name+”我是”+sex+”孩”);
         }
子类：
public xinxin2(String name,String sex)
{
           //调用父类的构造方法
           super(name,sex);
}
public void hello(){
                   System.out.println(“我是新来的！”);
           //调用父类的方法
           super.hello();
}
位置注意：调用父类的构造方法的语句（super语句）必须是构造方法中的第一条语句。
因为创建对象的时候，需要先创建父类对象，再创建子类对象。
注意：创建对象时，先创建父类对象，在创建子类对象。如果没有显示调用父类的构造方法，将自动调用父类的无参构造方法。

2.9学习总结

     多态性是面向对象编程的一种特性，和方法无关，
    简单说，就是同样的一个方法能够根据输入数据的不同，做出不同的处理，即方法的
    重载——有不同的参数列表（静态多态性）

　 而当子类继承自父类的相同方法，输入数据一样，但要做出有别于父类的响应时，你就要覆盖父类方法，

    即在子类中重写该方法——相同参数，不同实现（动态多态性）

2.10 注意事项：

（1）千万别为了获取其他类中的功能而继承，必须是类与类间有所属关系才可以继承。

（2）子类覆盖父类时必须保证子类权限大于等于父类，才可以覆盖，否则编译失败

（3）子类静态成员只能覆盖父类静态成员

3.java 的祖先类

所有类都直接或者间接地继承了java.lang.Object类，Object类中定义了所有的java对象都具有的相同行为，是所有类的祖先。

一个类如果没有使用extends关键字，那么这个类直接继承自Object类。

4.final关键字

final是一个关键字，可以用于修饰类，成员变量，成员方法。

特点：

它修饰的类不能被继承。没有子类，final类中的方法默认是final的。
它修饰的成员变量是一个常量。只能被赋值一次，赋值后值不再改变。
它修饰的成员方法是不能被子类重写的。
final不能用于修饰构造方法。
注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。
final修饰的常量定义一般都有书写规范,被final修饰的常量名称,所有字母都大写。

5.final和private的区别：

（1）final修饰的类可以访问；private不可以修饰外部类，但可以修饰内部类（其实把外部类私有化是没有意义的）。

（2）inal修饰的方法不可以被子类重写；private修饰的方法表面上看是可以被子类重写的，其实不可以，子类是看不到父类的私有方法的。

（3）final修饰的变量只能在显示初始化或者构造函数初始化的时候赋值一次，以后不允许更改；
private修饰的变量，也不允许直接被子类或一个包中的其它类访问或修改，但是他可以通过set和get方法对其改值和取值