继承 关键字 extends
class Child extends Praent{}
父类 和普通类写法相同
public class 父类类名{
}
子类
public class 子类类名 extends 父类类名{
}
tip:
创建一个class当成父类
Parent的class不用加主函数
public class Parent {
public Parent() {
System.out.println("调用Parent类的构造器");
}
}
再创建它的子类
就是再创建一个Child类当成子类
不用主函数
public class Child extends Parent{
public Child() {
System.out.println("调用Child构造器");
}
}
再创建它的子类
就是再创建一个Deno1类当成子类
用主函数
public class Demo1 {
public static void main(String[] args) {
// TODO Auto-generated method stub
new Child();
}
}
运行结果为:
调用Parent类的构造器
调用Child构造器
例子:
class Telephone {//电话类
String button="button:0~9";//成员属性
void call() {//拨打电话功能
System.out.println("开始拨打电话");
}
}
class Parent extends Telephone{//手机类继承电话类
String screen="screen:液晶屏";//成员属性
}
public class Demo1{
public static void main(String[] args) {
Parent motto =new Parent();
System.out.println(motto.button);//子类调用父类属性
System.out.println(motto.screen);//子类调用父类没有的属性
motto.call();//子类调用父类方法
}}
就是和上面一样的方式只是放在一起了
三元类的构造方法第一行都有一个隐藏的"super();"
作用是在执行该构造方法之前调用其父类的构造方法
Object类
getClass()方法
getClass()方法是Object类定义的方法
getClass().getname();
可以将getClass()方法与toString方法联合使用
toString()方法
功能:将一个对象返回为字符串形式,它会返回一个string 实例。当这个类换为字符串或与字符串连接时,将自动调用重写的toString()方法。
方法的重写
返回参数相同、方法名相同、传入参数相同、方法体不同
例子:
equals()方法
有两种比较对象方式,分别为”==“运算符与equals()方法。
例子:
public class Telephone {
int id;//身份证
String name;//名字
public Telephone (int id, String name) {
this.id=id;
this.name=name;
}
public boolean equals(Object obj) {//重写object类的equals()方法
if(this==obj)//如果参数与本类是同一个对象
return true;
if(obj==null)//如果参数是null
return false;
if(getClass()!=obj.getClass())//如果参数与本类类型不同
return false;
Telephone other=(Telephone)obj;//将参数强转成本类类型对象
if(id!=other.id)//如果两者的身份证不相等
return false;
return true;
}
public String toString(){//重写Object类的toString()方法
return name;//只输出名字
}
public static void main(String[] args) {
Telephone p1=new Telephone(220,"tom");
Telephone p2=new Telephone(220,"汤姆");
Telephone p3=new Telephone(330,"张三");
Object o=new Object();
System.out.println(p1+"与"+p2+"是否为同一人?");
System.out.println("equals()方法的结果:"+p1.equals(p2));
System.out.println("==运算符的结果:"+(p1==p2));
System.out.println();
System.out.println(p1+"与"+p3+"是否为同一人?");
System.out.println(p1.equals(p3));
}
}
运行结果:
对象类型的转换
Dog a=new Animal ();
向上转型
将子类对象赋值给父类引用
自动类型转换
Animal a=new Dog ();
子类重写父类的方法
强制性转换
注意:
两个没有继承关系的对象不可以进行向上转型或者向下转型
父类对象可以强制转换为子类对象,但有一个前提:这个父类对象要先引用这个子类的对象
例:
public class Bird {}
class Pigeon extends Bird{}
class Demo4{
public static void main(String[] args) {
Bird bird =new Pigeon();//某只鸽子是一只鸟
Pigeon pigeon=(Pigeon)bird;//某只鸟是一只鸽子
}
}
使用instanceof关键字判断对象类型
语法格式为:
myobject instanceof ExampleClass
myobject:某类的对象引用
ExampleClass:某个类
误区警示:
imstanceof是java语言的关键字,java语言中的关键字都为小字
对象名 instanceof 类名
判断该对象是否属于这个类
例:
方法的重载
方法名相同 参数不同
例子:
public class OverLoadTest {
public static int add (int a,int b) {//定义一个方法
return a+b;
}
public static double add (double a,double b) {//与第一个方法名称相同、参数不同
return a+b;
}
public static int add(int a) {//与第一个方法参数个数不同
return a;
}
public static int add(int a,double b) {//先int参数,后double参数
return a;//输出int的参数值
}
public static int add(double a,int b) {//先double参数,后int参数
return b;//输出double的参数值
}
public static void main(String[] args) {
System.out.println("调用add(int,int)方法:"+add(1,2));
System.out.println("调用add(double,double)方法:"+add(2.1,3.3));
System.out.println("调用add(int)方法:"+add(1));
System.out.println("调用add(int,double)方法:"+add(5,8.0));
System.out.println("调用add(double,int)方法:"+add(5.0,8));
}
运行结果:
不定义长参数方法的语法:
返回值 方法名(参数数据类型...参数名称)
例:
public class OverLoadTest2 {
public static int add (int a,int b) {
return a+b;
}
public static double add (double a,double b) {
return a+b;
}
public static int add(int a) {
return a;
}
public static int add(int a,double b) {
return a;
}
public static int add(double a,int b) {
return b;
}
public static int add(int...a) {//定义不定义参数方法
int s=0;
for(int i=0;i<a.length;i++){//根据参数个数做循环操作
s+=a[i];//将每个参数累加
}
return s;//将计算结果返回
}
public static void main(String[] args) {
System.out.println("调用add(int,int)方法:"+add(1,2));
System.out.println("调用add(double,double)方法:"+add(2.1,3.3));
System.out.println("调用add(int)方法:"+add(1));
System.out.println("调用add(int,double)方法:"+add(5,8.0));
System.out.println("调用add(double,int)方法:"+add(5.0,8));
System.out.println("调用不定义长参数方法:"+add(1,2,3,4,5,6,7,8,9));
System.out.println("调用不定义长参数方法:"+add(1));
}
}
运行结果为:
final关键字
final变量
在类中定义PI值,语句:
final double PI=3.14
例:
final 方法
final修饰变量——不可以被修改(常量)
final修饰方法——不可以被重写
final修饰类——不可以被继承
一个定义为private方法隐式指定为final类型,无须将一个定义为private方法再指定为final类型,语法:
prvate final void test(){
...//省略一些代码
}
例:
多态:
class Shape{}//图形类
class Square extends Shape{}//正方形类继承图形类
class Circular extends Shape{}//圆形继承图形类
public class Demo6 {
public static void draw(Shape s) {//绘制方法
if(s instanceof Square) {//如果是正方形
System.out.println("绘制正方形");
}else if (s instanceof Circular) {//如果是圆形
System.out.println("绘制圆形");
}else {
System.out.println("绘制父类图形");//如果是其他类型
}
}
public static void main(String[]args) {
draw(new Shape());
draw(new Square());
draw(new Circular());
}
}
运行结果:
抽象类与接口
抽象类
抽象方法
修饰符 abstract 返回参数 方法名(传入参数)
抽象类 有抽象方法的类一定是抽象类
修饰符 abstract class 类名{
}
如果声明一个抽象方法,就必须将承载这个抽象方法的类定义为抽象类,不能在非抽象类中获取抽象方法
接口
接口中所有的方法都没有方法体
所有方法都是抽象方法
在java中每个类实现多个接口
public:接口可以像类一样被权限修饰符修饰,但是public关键字仅限用于接口在与其同名的文件中被定义
interface:定义接口关键字
Paintable:接口名称
实现 implements
修饰符 class 类目 inplements 接口1 接口2..(
)
接口使用interface关键字定义,语法:
public interface Paintable{
void draw();//定义接口方法可省略public abstract关键字
}
一个类继承一个父类的同时再实现一个接口,可以写成以下形式:
public class Parallelogram extends Quadrangle implements Paintable{
...}
例子:
interface Paintable{//可绘制接口
public void draw();//绘制抽象方法
}
class Quadrangle{//四边形类
public void doAnything() {
System.out.println("四边形提供的方法");
}
}
class Parallelogram extends Quadrangle implements Paintable{
public void draw() {//由于该类实现了接口,所以需要覆盖draw()方法
System.out.println("绘制平行四边形");
}
}
class Square extends Quadrangle implements Paintable{
public void draw() {
System.out.println("绘制正方形");
}
}
class Circular implements Paintable{
public void draw() {
System.out.println("绘制圆形");
}
}
public class Demo7 {
public static void main(String[] args) {
Square s=new Square();
s.draw();
s.doAnything();
Parallelogram p=new Parallelogram();
p.draw();
p.doAnything();
Circular c=new Circular();
c.draw();
}
}