您的位置 首页 java

Java 面向对象的基础知识，你确定不了解一下吗？

智云科技发布于 2023年8月20日评论关闭阅读(67)

什么是面向对象？

面向对象是把问题按照一定规则划分为独立的对象，通过调用对象解决问题；面向对象的特点有封装性，继承性和多态性。

目录

​​​​​​

1.类与对象

类是具有共同特征的某类事物的抽象，对象是具体的事物；

1.类的定义

class 类名{

成员变量;

成员方法;

}

2.创建对象及使用方法

类名 对象名=new 类名（）;

对象名.成员方法（）;

3.封装性

封装的目的是保护内部数据信息，快速访问； 

 public class teachers {
  private  String name;
 private String id;
public String getName() {
return name;
}
public  void  setName(String name) {
this.name = name;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}

4.访问权限

访问范围

privatre

default

protected

public

同一类

yes

yes

yes

yes

同包不同类

yes

yes

yes

不同包子类

yes

yes

全局

yes

5. 构造方法

a.名称与类名相同；

b.无返回值类型声明，且无返回值； 

 class  Rectangle {
 private int width,length;
public  Rectangle(int width,int length) {
this.width=width;
this.length=length;
}
}

c.重载

方法名相同，成员变量不同 

 class Rectangle{
 private int width,length;
public  Rectangle(int width) {
this.width=width;
}
public  Rectangle(int width,int length) {
this.width=width;
this.length=length;
}
}

6.this关键字

成员变量与局部变量重名；

7. static 关键字

静态属性或全局属性，通过类名直接访问；

例题：

B1– 股票 类(封装)返回

(时间限制：1000ms 内存限制：65536KB)

描述统计

设计一个名为Stock的类。这个类包括（不限于以下数据和方法）：

一个名为symbol的字符串数据域表示 股票代码 ；

一个名为name的字符串数据域表示股票名字；

一个名为previousClosingPrice的double类型数据域存储前一日的股票值；

一个名为currentPrice的double类型数据域，存储当前的股票值；

创建一支有特定代码和名字的股票构造方法；

一个名为getChange()的方法返回从previousClosingPrice到currentPrice值的变化（currentPrice-previousClosingPrice大于零返回1，小于零返回-1，等于零返回0）。

根据输入数据（以逗号分隔）创建一个Stock对象，输出股票基本信息和股票值的变化。

！！！注意：输入输出部分尽量直接拷贝参考代码后修改进行，以免因为符号不一致造成错误。

输入

输入一个股票的信息，以英文逗号为分隔（symbol,name,currentPrice,previousClosingPrice）

输入语句示例：

Scanner s=new Scanner(System.in);

String infomation=s.nextLine();

String[] info=infomation.split(“,”);

Stock stock=new Stock(info[0],info[1]);

float current=(Float. parseFloat (info[2]));

float previous=(Float.parseFloat(info[3]));

输出

根据股票涨跌，输出股票相关信息，具体如下–

输出内容：

System.out.print(“股票代号：”+stock.getSymbol());

System.out.print(“；股票名称：”+stock.getName());

System.out.print(“；当前价格：”+stock.getCurrentPrice());

if (stock.getChange()==1)

System.out.print(“；涨/跌：涨”);

else if(stock.getChange()==-1)

System.out.print(“；涨/跌：跌”);

else

System.out.print(“；涨/跌：平”);

难度

一般

输入示例

2019001, java ,3.5,3.45

输出示例

股票代号：2019001；股票名称：Java；当前价格：3.5；涨/跌：涨 

 import java.util.Scanner;
public class B1股票类封装 {
    public static void main(String[] args) {
    String symbol,name;
    Scanner s=new Scanner(System.in);
    String infomation=s.nextLine();
    String[] info=infomation.split(",");
    Stock stock=new Stock(info[0],info[1]);
    float current=(Float.parseFloat(info[2]));
    float previous=(Float.parseFloat(info[3]));
    System.out.print("股票代号："+stock.getSymbol());
    System.out.print("；股票名称："+stock.getName());
    System.out.print("；当前价格："+stock.getCurrentPrice(current));
    if (stock.getChange(current,previous)>0)
    System.out.print("；涨/跌：涨");
    else if(stock.getChange(current,previous)<0)
    System.out.print("；涨/跌：跌");
    else
    System.out.print("；涨/跌：平");
    }
}
class Stock{
     String symbol,name;
     float CurrentPrice,y;
     public  Stock(String symbol,String name) {
         this.symbol=symbol;
         this.name=name;
     }
     public String getSymbol() {
         return symbol;
     }
     public void setSymbol(String symbol) {
         this.symbol=symbol;
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name=name;
     }
     public void setCurrentPrice(float CurrentPrice) {
            this.CurrentPrice=CurrentPrice;
        }
     public float getCurrentPrice(float CurrentPrice) {
        return CurrentPrice; 
     }
     public float getY() {
         return y;
     }
     public void setY(float y) {
         this.y=y;
     }
     public float getChange(float CurrentPrice,float y) {
         return CurrentPrice-y;
     }
}

2.继承

类似之间有重复部分，继承可以避免重复写代码；

public class 子类名 extends 父类名{

}

注：a.Java中类只能单继承，即一个子类只能有一个父类；

b.一个父类可以有多少个子类；

c.多层继承，相当于爷爷，爸爸，孙子 ；

1.覆盖方法（方法重写）

子类继承父类中方法，子类可以对方法进行修改； 

 class A {
public void ss（）{
System.out.println("c/c++");
}
}
class B extends A{
public void ss(){
System.out.println("java");
}
}

注：子类只能访问父类中的非私有方法，且无法对方法的访问权限作出修改；

2.final关键字

阻止继承

a.阻止类再被继承 

 public final class B extends A{
.......
}//B将无法再被扩展

b. 阻止 方法覆盖 

 class A{
......
public final String getName(){
return name;
}
......
}//子类将无法对getName重写

例题：

B2–三角形(继承)

(时间限制：1000ms 内存限制：65536KB)

描述统计

设计一个三角形Triangle类，其属性包含String类型的名字、三个float类型的边长。一个判断是否为三角形的isTriangle方法，以及重写的 toString 方法输出三角形的三条边长。

设计三角形类的子类RightTriangle（直角三角形），实现一个计算周长的方法getPerimeter和计算面积的方法getArea。

测试根据输入三角形的基本信息（三条边），判定输入是否为三角形，如果是则输出其三条边长；判断此三角形是否为直角三角形，如果是则输出其周长和面积。

！！！注意：输入输出部分尽量直接拷贝参考代码后修改进行，以免因为符号不一致造成错误。

输入

字符串 ，包括三角形的三条边长。输入部分代码参考：

Scanner s=new Scanner(System.in);

//输入时格式为”边a,边b,边c”–直角三角形边a、b分别为两个直角边，边c为斜边

String trangleOne=s.nextLine();

String[] ones=trangleOne.split(“,”);

float sidea,sideb,sidec;

sidea=Float.parseFloat(ones[0]);

sideb=Float.parseFloat(ones[1]);

sidec=Float.parseFloat(ones[2]);

输出

根据输入的三条边判断，如果不是三角形则输出提示信息，如果是普通三角形则输出三边长，如果是直角三角形还要再输出周长和面积值。输出部分代码参考：

if(triangle.isTriangle()) {

System.out.println(“三角形三条边长–“+%这里获取第一条边%+”,\t”+%这里获取第二条边%+”,\t”+%这里获取第三条边%);//说明：%%括住的部分需要用自己的代码替换

if (%调用直角三角形类isRightTriangle()%)//说明：%%括住的部分需要用自己的代码替换

System.out.println(“直角三角形周长:”+%调用自己构造的getPerimeter()方法%+”\t直角三角形面积:”+%调用自己构造的getArea()方法%);//说明：%%括住的部分需要用自己的代码替换

}

else

System.out.println(“请输入正确的三条边数据”);

}

难度

一般

输入示例

**输入为英文逗号分隔的三条边长，例如：

3,3,3

**如果是直角三角形，则输入如：

3,4,5

**如果不是三角形的三条边，则输入如：

2,3,5

（注：星号开头的不是输入中的内容，输入只是其下面的一行）

输出示例

**如果判定是三角形，则输出三条边的边长，例如：

三角形三条边长–3.0, 3.0, 3.0

**如果还是直角三角形，还需要输出其周长和面积值，如：

三角形三条边长–3.0, 4.0, 5.0

直角三角形 周长:12.0 直角三角形面积:6.0

**如果输入的不是三角形，则输出提示信息：

请输入正确的三条边数据

（注：星号开头的不是输出中的内容，输出只是其下面的一行） 

 import java.util.Scanner;
public class B23 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner s=new Scanner(System.in);
        String trangleOne=s.nextLine();
        String[] ones=trangleOne.split(",");
        float sidea,sideb,sidec;
        sidea=Float.parseFloat(ones[0]);
        sideb=Float.parseFloat(ones[1]);
        sidec=Float.parseFloat(ones[2]);
        Triangle triangle=new Triangle(sidea,sideb,sidec);
        if(triangle.isTriangle()==1) {
            System.out.println("三角形三条边长--"+sidea+",\t"+sideb+",\t"+sidec);//说明：%%括住的部分需要用自己的代码替换
            if (triangle.isRightTriangle()==1)//说明：%%括住的部分需要用自己的代码替换
            System.out.println("直角三角形周长:"+triangle.getPerimeter()+"\t直角三角形面积:"+triangle.getArea());//说明：%%括住的部分需要用自己的代码替换
            }
            else
            System.out.println("请输入正确的三条边数据");
            }
}       
class Triangle{
    String name;
    float a,b,c;
    public Triangle(float a,float b,float c) {
        this.a=a;
        this.b=b;
        this.c=c;
    }
    public int isTriangle() {
        if(a+b>c&&(c-b<a||c-a<b)) {
            return 1;
        }
        else {
            return 0;
        }
    }
    public int isRightTriangle() {
        if(a*a+b*b==c*c) {

3.接口

1.抽象类和抽象方法

方法中缺少方法体 

  abstract  class 抽象类名{
属性;
访问权限 返回值类型 方法名称(参数){      //普通方法
return 返回值;
}
访问权限 abstract 返回值类型 抽象方法名称(参数);  //抽象方法
}

注：a.抽象方法必须再抽象类中；

b.使用abstract关键字

c.如果一个类继承了抽象类，子类必须实现抽象类中所有的抽象方法；

2.接口

全由抽象方法组成的纯抽象类叫做接口，还可包括默认方法和 静态方法 ； 

 public interface 接口名 extends 接口一，接口二...{
public static final 数据类型 常量名 = 常量值;
public abstract 返回值类型 抽象方法名称(参数);
}

例题：

B3–java（接口）

(时间限制：1000ms 内存限制：65536KB)

描述统计

利用接口做参数，写个计算器，能完成加减乘除运算。

（1）定义一个接口Compute含有一个方法int computer(int n, int m)。

（2）设计四个类分别实现此接口，完成加减乘除运算。

（3）设计一个类UseCompute，类中含有方法：public void useCom(ICompute com, int one, int two)，此方法能够用传递过来的对象调用 computer 方法完成运算，并输出运算的结果。

（4）设计一个主类 Test ，调用UseCompute中的方法useCom来完成加减乘除运算。

如果加减乘除对应的四个类分别是：Add、Minus、Mul、Div，那么 main方法的代码如下：

public static void main(String[] args) {

// TODO Auto-generated method stub

UseCompute fun=new UseCompute();

Scanner s=new Scanner(System.in);

int i=s.nextInt();

int j=s.nextInt();

fun.UseCom(new Add(),i,j);

fun.UseCom(new Minus(),i,j);

fun.UseCom(new Mul(),i,j);

fun.UseCom(new Div(),i,j);

}

输入

输入要参与算数运算的两个整数，如8 2

输出

8+2 is 10

8-2 is 6

8*2 is 16

8/2 is 4

难度

中等

输入示例

10

5

输出示例

10+5 is 15

10-5 is 5

10*5 is 50

10/5 is 2 

 import java.util.Scanner;
public class B3 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        UseCompute fun=new UseCompute();
        Scanner s=new Scanner(System.in);
        int i=s.nextInt();
        int j=s.nextInt();
        fun.UseCom(new Add(),i,j);
        fun.UseCom(new Minus(),i,j);
        fun.UseCom(new Mul(),i,j);
        fun.UseCom(new Div(),i,j);
    }
}
interface Compute{
    void computer(int n, int m);
}
class Add implements Compute{
    public void computer(int n, int m) {
        System.out.printf("%d+%d is %d\n", n,m,n+m);
    }
}
class Minus implements Compute{
    public void computer(int n, int m) {
        System.out.printf("%d-%d is %d\n", n,m,n-m);
    }
}
class Mul implements Compute{
    public void computer(int n, int m) {
        System.out.printf("%d*%d is %d\n", n,m,n*m);
    }
}
class Div implements Compute{
    public void computer(int n, int m) {
        System.out.printf("%d/%d is %d", n,m,n/m);
    }
}
class UseCompute{
    public void UseCom(Compute com, int one, int two)
    {
        com.computer(one, two);
    }
}

3.内部类

定义在另一个类中的类叫内部类，内部类可以对同一个包中的其他类隐藏，内部类方法可以访问定义在这个类的作用域中的数据，包括原本私有的数据。

a.成员内部类

外部类名.内部类名 变量名=new 外部类名().new 内部类名(); 

 class A{
int m=0;
void test1 () {
System.out.println("外部类成员方法");
}
class Inner {
int n=1;
void show1(){
System.out.println("外部成员变量m="+m);
test1();
}
void show2 () {
System.out.println("内部类成员方法");
}
}
void test2 (){
Inner inner =new Inner();
System.out.println("局部内部类变量n="+n);
inner.show();
}
}

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

b.局部内部类 

 class A{
int m=0;
void test1() {
System.out.println("外部类成员方法");
}
void test2 (){
class Inner{
int n=1;
void show(){
System.out.println("外部成员变量m="+m);
test1();
}
}
Inner inner =new Inner();
System.out.println("局部内部类变量n="+n);
}
}

注：局部内部类可以访问外部类的所有成员变量和方法，而局部内部类中的变量和方法只能在所属方法中访问。

c.静态内部类

外部类名.静态内部类名 变量名 = new 外部类名().静态内部类名(); 

 class A{
static int m=0;
static class Inner {
int n=1;
void show(){
System.out.println("外部静态变量m="+m);
}
}
}

注：静态内部类只能访问外部类的静态成员

d.匿名内部类 

 new 父接口(){
//匿名内部类实现部分}
  
 interface A{
void shout();
}
public class Test{
public static void main (String[] args){
String name="小明";
as(new A(){
public void shout(){
System.out.println(name+"xiaoming");
}
});
}
public static void as(A a){
a.shout();
}
}

4.异常

a. try…catch 

 try{
//程序代码
}catch(ExceptionType e){
//对ExceptionType的处理
}

b. throws关键字

修饰符 返回值类型 方法名 （参数…) throws 异常类1，异常类2…{

//方法体

}

例题：

Java202期末M6

(时间限制：1000ms 内存限制：65536KB)

描述统计

创建一个由10个由1-10整数顺序构成的数组。提示用户输入数组的下标，然后显示对应的元素值。如果下标越界，就抛出异常。显示消息Out Of Bounds！。

输入

下标

输出

对应的值或抛出异常

难度

中等

输入示例

4

输出示例

5 

 import java.util.Scanner;
public class Java202期末M6 {
 
    public static void main(String[] args) throws ArrayIndexOutOfBoundsException{
        // TODO Auto-generated method stub
    Scanner iScanner=new Scanner(System.in);
    int a; 
    a=iScanner.nextInt();
    try{
 
        te(a);
 
    }catch (ArrayIndexOutOfBoundsException e) {
 
        System.out.println("Out Of Bounds!");
 
    }
    }
    public static void te(int x) throws ArrayIndexOutOfBoundsException{
    int[] c;
    c=new int[10];
    for(int i=0;i<=x;i++) {
        c[i]=i+1;
    }
    System.out.printf("%d\n", c[x]);
}
}
标签:
打赏 点赞(3)

文章来源：智云一二三科技

文章标题：Java 面向对象的基础知识，你确定不了解一下吗？

文章地址：https://www.zhihuclub.com/187195.shtml

关于作者: 智云科技

相关文章

热门文章

1分享新浪图床上传接口源码

点赞(953)阅读(61,230)

2PHP简单实现路由Route功能

点赞(1.16K)阅读(35,975)

3Tideways、xhprof 和 xhgui 打造 PHP 非侵入式监控平台

点赞(386)阅读(4,306)

4centos系统如何查看是否安装了mysql

点赞(551)阅读(3,798)

5curl 工具简述

点赞(530)阅读(2,987)
网站地图