目录
子类在父类创建好之后,创建子类对象的同时也会调用父类的构造方法
主要包括clone()、finalize()、equals()、toString()、getClass()等
注意:Object类中的getClass()、notify()、notifyAll()、wait()等方法不能被重写,因为这些方法被定义为final类型
对象名+instanceof+类名(判断对象是否属于这个类或者是他的子类)
一.继承
-
Java语言每个类只能继承一个父类
public class 父类类名{
}
-
子类
public class 子类类名 extends 父类类名{
}
-
子类在父类创建好之后,创建子类对象的同时也会调用父类的构造方法
public class Parent{
public Parent() {
System.out.println("调用Parent构造器");
}
}
public class Child extends Parent {
public Child() {
super();
System.out.println("调用Child类的构造器");
}
}
public class Demo1 {
public static void main(String[] args) {
// TODO Auto-generated method stub
new Child();
}
}
-
子类继承父类之后可以调用父类创建好的属性和方法
public class Telephone { //电话类 String button = "butter:0~9"; //成员属性,十个按键 void call() { //拨打电话功能 System.out.println("开始拨打电话"); } } public class Mobile extends Telephone{ //手机类继承电话类 String screen = "screen:液晶屏"; //成员属性,液晶屏幕 } public class Demo2 { public static void main(String[] args) { // TODO Auto-generated method stub Mobile motto = new Mobile(); System.out.println(motto.button); //子类调用父类属性 System.out.println(motto.screen); //子类调用父类没有的属性 motto.call(); //子类调用父类方法 motto.getClass().getName(); //拿到motto类和类的名字 } }
二,Object
-
主要包括clone()、finalize()、equals()、toString()、getClass()等
-
注意:Object类中的getClass()、notify()、notifyAll()、wait()等方法不能被重写,因为这些方法被定义为final类型
-
getClass()方法
getClass()方法是Object类定义的方法,它会返回对象执行时的Class实例,然后使用此实例调用getName()方法可以取得类的名称
getClass().getName();
-
toString()方法
toString()方法的功能是将一个对象返回为字符串形式,它会返回一个String实例。在实际应用中通常重写toString()方法,为对象提供一个特定的输出模式。当这个类转换为字符串或字符串连接时,将自动调用重写的toString()
public class Student {
String name;
int age;
public Student(String name,int age) {
this.name = name;
this.age = age;
}
public String toString() {
return "我叫" + name +", 今年" + age + "岁。";
}
public static void main(String[]args) {
Student s1 = new Student("张三",16);
System.out.println(s1);
Student s2 = new Student("李四",19);
System.out.println(s2);
}
}
-
equals()方法
在Java语言中,有两种比较对象的方式,分别把“==”运算符与equals()方法。两者的区别在于:“==”比较的是两个对象引用内存地址是否相等,而equals()方法比较的时两个对象的实际内容。
public class People {
int id; //身份证号
String name; //名字
public People(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;
People other = (People)obj; //将参数强制转换成本类对象
if(id!=other.id) //如果两者的身份证号不相等
return false;
return true;
}
public String toString() { //重写Object类的toString()方法
return name; //只输出名字
}
public static void main(String[]args) {
People p1 = new People(220,"tom");
People p2 = new People(220,"汤姆");
People p3 = new People(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.print(p1+"与"+p3+"是否为同一人?");
System.out.println(p1.equals(p3));
System.out.print(p1+"与"+o+"+是否为同一人?");
System.out.println(p1.equals(o));
}
}
三、对象类型的转换
-
向上转型
向上转型可以被理解为将子类类型的对象转换为父类类型的对象,即把子类类型的对象直接赋值给父类类型的对象
将子类对象(等号右边)向父类引用(等号左边)
自动类型转换
Animal a=new Dog();
-
向下转型
向下转型可以被理解为将父类类型的对象转化为子类类型的对象
将父类对象向子类引用
需要进行强制类型转换
Dog a=(Dog) new Animal;,
class Bird {}
class Pigeno extends Bird{}
public class Demo4{
public static void main(String[]args) {
Bird bird = new Pigeno(); //某只鸽子是一只鸟
Pigeno pigeno =(Pigeno) bird; //强制类型转换,某只鸟是一只鸽子
}
}
四、使用iinstanceof关键字判断对象类型
-
对象名+instanceof+类名(判断对象是否属于这个类或者是他的子类)
class Quadrangle{} class Square extends Quadrangle{} class Circular{} public class Demo5 { public static void main(String args[]) { Quadrangle q = new Quadrangle(); Square s = new Square(); System.out.println(q instanceof Square); System.out.println(s instanceof Quadrangle ); //条件操作类型Quadrangle和Circular不兼容 ,四边形类和圆形类没有继承关系,因此两者不能使用instanceof关键字进行比较 //System.out.println(q instanceof Circular); } }
五、方法的重载
-
方法名相同,参数不同
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; //输出int参数 } public static void main (String agrs[]) { 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) { //先int参数,后double参数
return a; //输出int参数
}
public static int add(double a,int b) { //先double参数,后int参数
return b; //输出int参数
}
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 agrs[]) {
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变量
final修饰变量——不可以被修改(常量)
final关键字可以用于变量声明,一旦该变量被设定,就不可以再改变该变量的值。
-
final方法
final修饰方法——不可以被重写
在修饰权限中曾经提到过private修饰符,如果一个父类的某个方法被设置为private,子类将无法访问该方法,自然无法覆盖该方法。也就是说,一个定义为private的方法隐式被指定为final类型,因此无须将一个定义为private的方法再定义为final类型
private final void test(){
....//省略一些程序代码
}
class Dad {
public final void turnOnTheTv() {
System.out.println("爸爸打开了电视");
}
}
class Baby extends Dad{
public final void turnOnTheTv() { //此行处有多个标记,覆盖爸爸.打开电视,无法覆盖爸爸的最终方法
System.out.println("宝宝也要打开电视"); //不能覆盖Dad中的final方法
}
}
-
final类
final修饰类——不可以被继承
final类名{}
七、多态
-
同一方法或同一个地方出现不同的形态就叫多态
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()); } }
从本实例的运行结果中可以看出,以不同类对象为参数调用draw()方法,可以处理不同的图形绘制问题。使用多态节省了开发和维护时间,因为程序员无须在所有的子类中定义执行相同功能的方法,避免了大量重复代码的编写。同时,只要实例化一个继承父类的子类对象,即可调用相应的方法,如果需求发生了变更,只需要维护一个draw()方法即可。
八、抽象类与接口
-
抽象类
有抽象方法的类一定是抽象类
使用abstract关键字定义的类称为抽象类,而使用这个关键字定义的方法称为抽象方法,抽象方法没有方法体,这个方法本身没有任何意义,除非它被重写,而承载这个这个抽象方法的抽象类必须被继承,实际上抽象类除了被继承没有任何意义。
当父类是一个抽象类,子类继承并重写,遵循父类的规则重写,否则就会报错
修饰符 abstract class 类名{
}
eg:public abstract class Sun{
}
public abstract class Parent{
abstract void testAbstract(); //定义抽象方法
}
-
抽象方法
修饰符 abstract 返回参数 方法名(传入参数);
eg:public abstract void methodName();
-
接口
所有方法都是抽象方法
类里有多个接口,当只重写一部分时,不会报错,因为接口里重写的时抽象方法,在抽象类里不会报错
修饰符 interface 接口名{
}
接口是抽象类的延申,可以将它看作是纯粹的抽象类,接口中的所有方法都没有方法体
-
实现 implements
Java中不允许出现多重继承,但使用接口就可以实现多重继承,一个类可以同时实现多个接口,因此可以将所有需要继承的接口放置在implements关键字后并使用逗号隔开,实现多个接口的语法
修饰符 class 类名 implements 接口,接口2....{
}
interface Paintable{ //可绘制接口
public void draw(); //绘制抽象方法
}
class Qu{ //四边形类
public void doAnything() {
System.out.println("四边形提供的方法");
}
}
//平行四边形类,继承四边形类,并实现了可绘制接口 先写继承,后写实现
class Parallelogram extends Qu implements Paintable{
public void draw() { //由于该类实现了接口,所以需要覆盖draw()方法
System.out.println("绘制平行四边形");
}
}
//正方形类,继承四边形类,并实现了可绘制接口
class Sq extends Qu implements Paintable{
public void draw() {
System.out.println("绘制正方形");
}
}
//圆形类,仅实现了可绘制
class Cir implements Paintable{
public void draw() {
System.out.println("绘制圆形");
}
}
public class Demo7 {
public static void main(String[] args) {
Sq s = new Sq();
s.draw();
s.doAnything();
Parallelogram p = new Parallelogram();
p.draw();
p.doAnything();
Cir c = new Cir();
c.draw();
}
}