什么是面向对象？面向对象是把问题按照一定规则划分为独立的对象，通过调用对象解决问题；面向对象的特点有封装性，继承性和多态性，下面我们就来说一说关于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]);
}
}
