java之继承和多态

最新推荐文章于 2024-06-12 11:59:04 发布

YUZHONg_s

最新推荐文章于 2024-06-12 11:59:04 发布

阅读量42

点赞数

分类专栏： java 文章标签： java 开发语言 jvm

本文链接：https://blog.csdn.net/YUZHONg_s/article/details/130764439

版权

java 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

继承和多态

继承和多态是面向对象非常重要的一个环节，继承能够复用一些定义好的类，减少代码冗余量，多态可以动态调整对现象的调用，降低对象之间的关系

类的封装

封装就是将类的某些信息隐藏在类内部，不允许外部程序直接访问，只能通过该类提供的方法来实现对隐藏信息的操作和访问。

封装的步骤一般是，对属性设置private 。为每一个属性创建get和set方法，用于属性的读写，在赋值和取值方法中加入对属性值的合法判断

```java //封装简易类demo import java.util.Scanner;

public class packagingClass { public static void main(String [] args){ Empolye em1=new Empolye(); System.out.println("请输入员工信息"); Scanner input=new Scanner(System.in); System.out.print("姓名:"); em1.setName(input.next()); System.out.print("年龄："); em1.setAge(input.nextInt()); System.out.print("手机号"); em1.setPhone(input.next()); System.out.print("地址"); em1.setAddress(input.next()); System.out.println("姓名"+em1.getName()); System.out.println("年龄"+em1. getAge()); System.out.println("手机号"+em1.getPhone()); System.out.println("地址"+em_1.getAddress());

} class Empolye{ private String name; private int age; private String address; private String phone; public String getName(){ return name; } public int getAge(){ return age; } public String getAddress(){ return address; } public String getPhone(){ return phone; } public void setName(String name){ this.name=name; } public void setAge(int age){ if(age>18 && age<40){ this.age=age; }else{ System.out.println("年龄必须在20-40之间"); } } public void setPhone(String phone){ if(phone.length() == 11){ this.phone=phone; }else{ System.out.println("手机号码不合法"); } } public void setAddress(String address){ this.address=address; } }

java //图书信息类 public class BookTest { public static void main(String [] args){ BookInfo books1=new BookInfo(); books1.setBookName("《小木偶》"); books1.setBookNum(201); books1.detail(); BookInfo books2=new BookInfo(); books2.setBookNum(190); books2.setBookName("《堂吉诃德》"); books2.detail(); } } class BookInfo{ private String bookName; private int bookNum; public String getBookName(){ return this.bookName; } public String getBookNum(){ return this.bookName; } public void setBookName(String name){ this.bookName=name; } public void setBookNum(int num){ if(num >200){ System.out.println(this.bookName+"书本不能超过两百页面"); this.bookNum=200; }else{ this.bookNum=num; }

}
public void detail(){
    System.out.println(this.bookName+"这本书共有"+this.bookNum+"页");
}

}

```

继承

继承通过extends关键字进行继承。如果在父类中存在有参的构造方法并没有重载无参的构造方法，那么在子类中必须要有有参的构造方法，因为如果在子类中不含有构造方法，默认调用父类无参的构造方法，而在父类中没有无参的构造方法，会出错

## super关键字因为子类不能继承父类的构造方法，因此，如果要调用父类的构造方法，可以使用super关键字，super可以访问父类的构造方法，普通方法和属性

java public class supers { public static void main(String [] args){ Liu l=new Liu(); l.display(); } } class People{ public int age=18; public void message(){ System.out.println("this is Father"); } } class Liu extends People{ public void message(){ System.out.println("this is Child"); } public int age=12; public void display(){ message(); super.message(); System.out.println("父类里的年龄是"+super.age); //通过super调用父类的属性和方法 } }

this和super的区别

this指向的是当前对象，super指向的是父类对象 this()调用的是当前对象的构造方法，super调用的是父类的构造方法

对象类型转换

对象类型转换指的是创建对象时候，类型是父类，new的对象却是子类，或者类型是子类，这样去new(sonClass) fatherClass;

java public class Anmial{ public static void main(String [] args){ Anmials anmials=new Dog(); //向上转型，把dog类转换为Anmials类 Dog dog=(Dog) anmials;//向下转型，把animals类转换未Dog类 System.out.println(anmials.name); System.out.println(anmials.StaticName); anmials.eat(); anmials.staticEat(); dog.eat(); dog.staticEat(); } } class Anmials{ public String name="Anmials:动物"; public String StaticName="Anmail:可爱的动物"; public void eat(){ System.out.println("吃饭"); } public void staticEat(){ System.out.println("动物在吃饭"); } } class Dog extends Anmials{ public String name="dog:狗"; public String str="喵星人"; public String StaticName="不，我是汪星人"; public void eat(){ System.out.println("吃饭"); } public void staticEat(){ System.out.println("狗子在吃饭"); } public void eatMethod(){ System.out.println("狗喜欢吃*"); } }

方法重载

java允许同一个类中定义多个同名方法，只要它们的形参列表不同即可，如果同一个类中包含了两个或者两个以上方法名相同的方法，但是参数列表不同这种情况称为方法重载

方法重写

在子类中，如果有跟父类相同名称，相同返回类型，相同参数列表的方法，称为方法的重写

## 多态多态是面向对象语言的一个重要特征，它是指在父类中定义的属性和方法被子类继承之后，可以具有不同的数据类型或表现出不同的含义。如果要实现多态，必须要满足，继承，重写，向上转型才能实现

```java public class Anmial{ public static void main(String [] args){ Figure figure; figure=new Rectangle(9.1,9.2); System.out.println(figure.area()); figure=new Tirangle(9.1,9.2); System.out.println(figure.area()); figure=new Figure(1.1,1.2); System.out.println(figure.area()); } }

class Figure{ public double dim1; public double dim2; public Figure(double dim1,double dim2){ this.dim1=dim1; this.dim2=dim2; } public double area(){ System.out.println("父类里的方法，没有实际意义"); return 0; } } class Rectangle extends Figure{ public Rectangle(double dim1, double dim2) { super(dim1, dim2); } public double area(){ System.out.println("长方形的面积"); return this.dim1 * this.dim2; } }

class Tirangle extends Figure{ public Tirangle(double dim1,double dim2){ super(dim1,dim2); } public double area(){ System.out.println("三角形的面积"); return this.dim1 * this.dim2 /2; } } ```

instanceof

instanceof 用于判断对象是否是一个类，或者接口，抽象类。

```java public class Anmial{ public static void main(String [] args){ Figure figure=new Figure(1.1,9.2); Rectangle rectangle=new Rectangle(1.2,9.2); Tirangle tirangle=new Tirangle(1.6,9.2); System.out.println(figure instanceof Figure); System.out.println(rectangle instanceof Figure); System.out.println(tirangle instanceof Figure); } }

class Tirangle extends Figure{ public Tirangle(double dim1,double dim2){ super(dim1,dim2); } public double area(){ System.out.println("三角形的面积"); return this.dim1 * this.dim2 /2; } } ```

抽象类

抽象类使用abstract关键字来修饰，如果一个方法用abstract关键字来修饰表示这个方法是一个抽象方法。

抽象方法必须存在于抽象类中，子类如果继承抽象类时，必须要重写父类所有的抽象方法。抽象类不能被实例化

```java //抽象类 public class Anmial{ public static void main(String [] args){ Square square=new Square(2,2); System.out.println("正方形的面积为:"+square.area()); Triangle triangle=new Triangle(2,2); System.out.println("三角形面积为"+triangle.area()); } }

abstract class Shape{ public int width; public int height; public Shape(int w,int h){ this.width=w; this.height=h; } public abstract double area(); } class Square extends Shape{ public Square(int w, int h) { super(w, h); }

public double area(){
    return super.width * super.height;
}

} class Triangle extends Shape{ public Triangle(int w,int h){ super(w,h); } public double area(){ return 0.5super.widthsuper.height; } } ```

接口

接口是一种特殊的类，接口里没有执行体，有的只是全局常量和公共的方法

接口使用interface关键字定义，一个接口可以继承多个接口

```java public class Anmial{ public static void main(String [] args){ MathClass mathClass=new MathClass(1,2); System.out.println("1和2的和是"+mathClass.sum()); System.out.println("1和2比较大的是"+mathClass.maxNum());

} } interface IMath{ public int sum(); public int maxNum(); } class MathClass implements IMath{ private int num1; private int num2; public MathClass(int num1,int num2){ this.num1=num1; this.num2=num2; } public int sum(){ return this.num1+this.num2; } public int maxNum(){ if(this.num1>this.num2){ return this.num1; }else{ return this.num2; } } }

```

内部类

java里在类内部，可以再定义一个类，内部类分为实例内部类，静态内部类，成员内部类

```java // testDemo就是一个内部类 public class Anmial{ public static void main(String [] args){ Anmial.testDemo testdemo =new Anmial().new testDemo(); System.out.println(testdemo.getSum(1,2));

} private class testDemo{ public int getSum(int a,int b){ return a+b; } } }

```

实例内部类

实例内部类是指没有static修饰的内部类。

在外部类的静态方法和，外部类以外的其他类中，必须通过外部类的实例创建内部类的实例。
 如果是多层嵌套，则内部类可以访问外部类的所有成员。
 在内部类中不能定义static，除非带上final

静态内部类

静态内部类是指，内部类是用static修饰的内部类。

创建静态内部类的实例时，不需要创建外部类的实例。

静态内部类可以定义静态，

外部类以外的其他类，需要通过完整的类名访问内部类里的静态。

静态内部类可以直接访问外部类的静态，如果访问非静态需要通过外部类的实例去访问。

局部内部类

局部内部类是指在方法里定义一个类

局部类只在当前的方法内有效

局部内部类中不能定义静态

局部内部可以访问外部类的所有成员

```java public class persion{ public void test(){ class Inner{

}
//Inner就是局部内部类

} } ```

Lambda表达式(闭包)

```java

// ()->{} 这个就是Lanbda表达式(跟Es6的箭头函数有点像) public class bibao { public static Math math(char opr){ Math result; if(opr == '+'){ result=(int a,int b)->{ return a+b; }; }else{ result =(int a,int b)->{ return a-b; }; } return result; } public static void main(String [] args){ int n1=10; int n2=5; Math f1=math('+'); Math f2=math('-'); System.out.println(f1.calculateInt(n1,n2)); System.out.println(f2.calculateInt(n1,n2)); } } interface Math{ int calculateInt(int a,int b); }

```

常见的用途

#### 作为参数传递

```java public class bibao { public static void display(S s,int a,int b){ System.out.println(a+"+"+b+"的结果是"+ s.sum(a,b)); } public static void main(String [] args){ display((a,b)->a+b,10,6); display((a,b)->a+b,60,6); } }

interface S{ int sum(int a,int b); } ```

访问变量

访问非静态变量需要，用this访问 ```java public class bibao { public static int g=10; public static void display(S s,int a,int b){ System.out.println(a+"+"+b+"的结果是"+ s.sum(a,b)); } public static void main(String [] args){ display((a,b)->a+b+g,10,6); display((a,b)->a+b+g,60,6); } }

```

方法引用

class Demos{ public static int add(int a,int b){ return a+b; } public int sub(int a,int b){ return a-b; } } interface S{ int sum(int a,int b); } ```

YUZHONg_s

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java之继承和多态

继承和多态继承和多态是面向对象非常重要的一个环节，继承能够复用一些定义好的类，减少代码冗余量，多态可以动态调整对现象的调用，降低对象之间的关系类的封装封装就是将类的某些信息隐藏在类内部，不允许外部程序直接访问，只能通过该类提供的方法来实现对隐藏信息的操作和访问。封装的步骤一般是，对属性设置private 。为每一个属性创建get和set方法，用于属性的读写，在赋值和取值方法中加入对...
复制链接

扫一扫