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面向对象的主要内容,如果未能解决你的问题,请参考以下文章