Java面向对象（二）

source:http://blog.java1234.com/index.html?typeId=1

Java类的继承

1，继承定义以及基本使用

定义：子类能够继承父类的属性和方法；

注意点：Java中只支持单继承； 私有方法不能继承；

2，方法重写

所谓方法的重写 我们可以在子类中根据实际业务把父类的方法重写；

3，对象实例过程以及super关键字

对象实例化 先实例化调用父类构造方法，再调用子类实例化构造方法；

super关键主要是调用父类方法或者属性；

/**
 * 动物类
 * @author user
 *
 */
public class Animal {
 
    private String name; // 姓名
    private int age;  // 年龄
     
     
    /**
     * 无参父类构造方法
     */
    public Animal() {
        System.out.println("无参父类构造方法");
    }
     
    /**
     * 有参父类构造方法
     * @param name 姓名
     * @param age 年龄
     */
    public Animal(String name,int age) {
        System.out.println("有参父类构造方法");
        this.name=name;
        this.age=age;
    }
     
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
     
    public void say(){
        System.out.println("我是一个动物，我叫："+this.name+",我的年龄是："+this.age);
    }
}

/**
 * 定义一个Cat类，继承自Animal
 * @author user
 *
 */
public class Cat extends Animal{
 
    private String address;
     
 
    public String getAddress() {
        return address;
    }
 
    public void setAddress(String address) {
        this.address = address;
    }
 
    public Cat() {
        super();
        System.out.println("子类无参构造方法");
    }
 
    public Cat(String name, int age,String address) {
        super(name, age);
        this.address=address;
        System.out.println("子类有参构造方法");
    }
 
    /**
     * 重写父类的say方法
     */
    public void say(){
        super.say(); // 调用父类的say()方法
        System.out.println("我是一个猫，我叫："+this.getName()+",我的年龄是："+this.getAge()+"，我来自："+this.getAddress());
    }
     
    public static void main(String[] args) {
        Cat cat=new Cat("Mini",2,"火星");
        /*cat.setName("Mini");
        cat.setAge(2);*/
        cat.say();
    }
}

运行输出：

有参父类构造方法

子类有参构造方法

我是一个动物，我叫：Mini,我的年龄是：2

我是一个猫，我叫：Mini,我的年龄是：2，我来自：火星

final关键字

final是终结 完结的意思；

使用final声明的类不能被继承；

使用final声明的方法不能被子类覆盖；

使用final声明的变量不能被修改，即为常量；

抽象类

定义：在java中，含有抽象方法的类称为抽象类，同样不能生成对象；

注意点：

1，包含一个抽象方法的类是抽象类；

2，抽象类和抽象方法都要用abstract关键字修饰；

3，抽象方法只需要声明而不需要实现；

4，抽象类必须被子类（假如不是抽象类）必须重写抽象中的全部抽象方法；

5，抽象类不能被实例化；

/**
 * 定义一个抽象类People
 * @author user
 *
 */
public abstract class People {
 
    private String name;
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
     
    public void say(){
        System.out.println("我的姓名是："+this.getName());
    }
     
    /**
     * 定义一个抽象方法 职业 让子类去具体实现
     */
    public abstract void profession();
     
}

public class Student extends People{
 
    @Override
    public void profession() {
        System.out.println("职业是：学生");
    }
 }

public class Teacher extends People{
 
    @Override
    public void profession() {
        System.out.println("职业是：老师");
    }
}

public class Test {
 
    public static void main(String[] args) {
         
        Student student=new Student();
        student.profession();
         
        Teacher teacher=new Teacher();
        teacher.profession();
         
    }
}

运行输出：

职业是：学生

职业是：老师

接口

接口定义：一种特殊的“抽象类”，没有普通方法，由全局常量和公共的抽象方法所组成；

1，接口的定义

接口定义用关键字 interface，注意点：由于接口里的方法都是抽象的，所以abstract可以省略，实际开发一般都是省略的，开发者的习惯；

2，实现接口 可以实现一个或者多个接口，实现接口我们用implements关键字；

3，继承类和实现接口 先继承，后实现接口；

4，接口的继承  接口可以多继承；

对象的多态性

多态性表现：

1，方法的重载和重写；

2，可以用父类的引用指向子类的具体实现，而且可以随时更换为其他子类的具体实现；

public class Animal {
 
    public void say(){
        System.out.println("我是一个动物");
    }
}
public class Cat extends Animal{
 
    public void say(){
        System.out.println("我是一个猫");
    }
}
public class Dog extends Animal{
 
    public void say(){
        System.out.println("我是一个狗");
    }
}
public class Test {
 
    public static void main(String[] args) {
        Dog dog=new Dog();
        dog.say();
         
        Cat cat=new Cat();
        cat.say();
    }
}

运行输出：

我是一个狗

我是一个猫

//多态测试，父类引用指向子类具体实现
public class Test {
 
    public static void main(String[] args) {
        // 父类引用指向Dog子类的具体实现
        Animal animal=new Dog();
        animal.say();
         
        // 更换实现
        animal=new Cat();
        animal.say();
    }
}

运行输出：

我是一个狗

我是一个猫

 

对象的转型：

向上转型：子类对象->父类对象 安全

向下转型：父类对象->子类对象 不安全

Object类

Object类是所有类的父类；

Object类的常用方法

1，public String toString() 返回该对象的字符串表示；

2，public boolean equals(Object obj) 指示其他某个对象是否与此对象“相等”；

instanceof关键字

作用：判断一个对象是否属于一个类

格式：对象 instanceof 类 返回布尔类型

public class Animal {
 
    public void say(){
        System.out.println("我是一个动物");
    }
}
public class Dog extends Animal{
 
    public void say(){
        System.out.println("我是一只狗");
    }
}
public class Cat extends Animal{
 
    public void say(){
        System.out.println("我是一只猫");
    }
}
public class Test {
 
    public static void main(String[] args) {
        Animal dog=new Dog();
        System.out.println("dog对象是否属于Animal类："+(dog instanceof Animal));
        System.out.println("dog对象是否属于Dog类："+(dog instanceof Dog));
        System.out.println("dog对象是否属于Cat类："+(dog instanceof Cat));
    }
}

运行输出：

dog对象是否属于Animal类：true

dog对象是否属于Dog类：true

dog对象是否属于Cat类：false

匿名内部类

类的内部再定义类；

匿名内部类 这里指的是实例化内部对象 就是没有名字的内部类；

 

作用：假如某个类只使用一次，则可以使用匿名内部类；

包装类

每个基本类型都有一个对应的类；就是所谓的包装类；

 

1，装箱和拆箱

基本类型和类类型可以相互转换；

基本类型到类类型的转换叫做装箱；

类类型到基本类型的转换叫做拆箱；

public static void main(String[] args) {
        int a=1;
        Integer i=new Integer(a); // 装箱
        int b=i.intValue(); // 拆箱
        System.out.println("a="+a);
        System.out.println("i="+i);
        System.out.println("b="+b);
}

运行输出：

a=1

i=1

b=1

2，自动装箱和拆箱

在类类型和基本类型的转换中，是自动转换的 无需强制类型转换；

public static void main(String[] args) {
        Integer i=1; // 自动装箱的过程 自动把基本类型转换成类类型
        int i2=i; // 自动拆箱的过程 自动把类类型转成基本类型
        System.out.println("i="+i);
        System.out.println("i2="+i2);
}

运行输出：

i=1

i2=1

3，包装类的作用

因为包装类是类类型 所有jdk里提供了很多有用的方法给我们用；

比如从用户界面来两个字符串数据a,b 然后我们程序里要进行相加运算。这时候包装类就派上用场了，我们可以用包装类的方法类进行类型转换。

public static void main(String[] args) {
        String a="3";
        String b="5";
        int m=Integer.valueOf(a); // 调用Integer类的valuesOf方法 把字符串类型转换成int类型
        int n=Integer.valueOf(b);
        System.out.println("a+b="+(m+n));
}

运行输出：

a+b=8

单例模式

在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在；

 

有两种实现，一种是饿汉式，一种是懒汉式；

public class Singleton {
 
    /**
     * 构造方法私有
     */
    private Singleton(){
         
    }
     
    /**
     * 饿汉式单例实现
     */
    private static final Singleton single=new Singleton();
     
    /**
     * 获取实例
     */
    public static Singleton getInstance(){
        return single;
    }
}

public class Singleton2 {
 
    /**
     * 构造方法私有
     */
    private Singleton2(){
         
    }
     
    /**
     * 懒汉式单例实现 在第一次调用的时候实例化
     */
    private static Singleton2 single;
     
    /**
     * 获取实例
     */
    public synchronized static Singleton2 getInstance(){
        if(single==null){
            System.out.println("第一次调用的实例化");
            single=new Singleton2();
        }
        return single;
    }
}

public class Test {
 
    public static void main(String[] args) {
        Singleton singleton1=Singleton.getInstance();
        Singleton singleton2=Singleton.getInstance();
        System.out.println("饿汉式："+(singleton1==singleton2));
         
        Singleton2 singleton3=Singleton2.getInstance();
        Singleton2 singleton4=Singleton2.getInstance();
        System.out.println("懒汉式："+(singleton3==singleton4));
         
    }
}

运行输出：

饿汉式：true

第一次调用的实例化

懒汉式：true

表示图形

//实现一个类，用来表示图形，定义方法，可以分别计算出矩形和圆形的面积和周长
/**
 * 图形接口
 * @author user
 *
 */
public interface Graphical {
 
    /**
     * 求面积方法
     * @return
     */
    public float mianji();
     
    /**
     * 求周长方法
     * @return
     */
    public float zhouChang();
}

/**
 * 矩形类
 * @author user
 *
 */
public class Rectangle implements Graphical{
 
    private float c; // 长度
    private float k; // 宽度
     
     
     
    public Rectangle(float c, float k) {
        super();
        this.c = c;
        this.k = k;
    }
 
    @Override
    public float mianji() {
        return c*k;
    }
 
    @Override
    public float zhouChang() {
        return 2*(c+k);
    }
 
}

/**
 * 圆形
 * @author user
 *
 */
public class Circular implements Graphical{
 
    private float r; // 半径
     
     
     
    public Circular(float r) {
        super();
        this.r = r;
    }
 
    @Override
    public float mianji() {
        return (float) (Math.PI*r*r);
    }
 
    @Override
    public float zhouChang() {
        return (float) (2*Math.PI*r);
    }
 
}

public class Test {
 
    public static void main(String[] args) {
        Rectangle r=new Rectangle(2,3.5f);
        System.out.println("矩形的面积："+r.mianji());
        System.out.println("矩形的周长："+r.zhouChang());
         
        Circular c=new Circular(1.5f);
        System.out.println("圆形的面积："+c.mianji());
        System.out.println("圆形的周长："+c.zhouChang());
    }
}

运行输出:

矩形的面积：7.0

矩形的周长：11.0

圆形的面积：7.0685835

圆形的周长：9.424778

public void f1(){

        System.out.println("汪汪...");

    }