什么是面向对象?面向对象是把问题按照一定规则划分为独立的对象,通过调用对象解决问题;面向对象的特点有封装性,继承性和多态性,下面我们就来说一说关于java面向对象的理解?我们一起去了解并探讨一下这个问题吧!
java面向对象的理解
什么是面向对象?
面向对象是把问题按照一定规则划分为独立的对象,通过调用对象解决问题;面向对象的特点有封装性,继承性和多态性。
目录
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;
}
}
类似之间有重复部分,继承可以避免重复写代码;
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) {
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]);
}
}