Java面向对象

Posted careyzhao

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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("汪汪...");
    }

以上是关于Java面向对象的主要内容,如果未能解决你的问题,请参考以下文章

Java中面向对象的三大特性之封装

JAVA方法的定义

java 为啥要实现 function?

Java 封装

Java 封装

Java 封装