本文介绍了Java中的继承概念，包括子类如何调用父类的构造器和方法。接着讨论了Object类的关键方法如equals()和toString()。还涵盖了对象类型的转换、instanceof关键字的使用以及方法的重载。此外，讲解了final关键字的作用，包括final变量、方法和类。最后，详细阐述了多态的概念，并提到了抽象类和接口在Java编程中的重要性。
目录
子类在父类创建好之后，创建子类对象的同时也会调用父类的构造方法
主要包括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();
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
