java面向对象

最新推荐文章于 2022-11-21 22:29:45 发布

zmm0223

最新推荐文章于 2022-11-21 22:29:45 发布

阅读量158

点赞数 3

本文链接：https://blog.csdn.net/zmm0223/article/details/87380058

版权

6.1面向对象概述及介绍**

6.1.1面向对象

面向对象：是一种常见解决问题的思想，符合人们的思考习惯，可以将复杂的问题简单化，例如：下班回家吃饭，
面向过程思想：买菜-洗菜-做饭-吃饭（亲力亲为）执行者；
面向对象思想：叫外卖，下饭馆，女朋友做饭，（调用别人去做）指挥者。
面向过程是最基本的解决思路，面向对象是基于面向过程的。

6.2类与对象的关系**

类：是指一系列具有相似特征属性事物的统称。(概念）
对象:描述某类事物的实例。(实物）在java中通过new来创建
例如:定义人这一类，用person代替，

对象的创建：person p=new person()(类名 变量名=关键字 类名（））。

成员变量：实例变量，对象中的特有属性。
成员函数：实力函数，对象中的特有行为。

注：当成员变量与局部变量重名时，可用“this”关键字来区分，this的作用是 专指当前对象的引用，其次成员函数调用变量输出时，采取就近原则，如果成员函数中有该变量，调用成员函数中的变量，如果没有则调用成员变量。
成员变量私有化：设置访问权限，不让外部直接改变类中的成员变量，例如 private int age=15;该数据只能在内部访问，不能够被直接改变。
间接访问私有化成员变量：通过在类中创建set get的函数，间接的访问进行值的修改和获取，set get函数又被形象的称为 修改器和访问器。

例如：

class a{
 		private  int a=18;
 		public void setA(int a){
 				this.a=a;
 		}
 		public int getA(){
 				return this.a;
 		}
}

6.2.1 成员变量与局部变量的区别

1.定义区域不同作用域不同
成员变量定义在类中，整个类中都能够访问到；
局部变量定义在函数中，语句，局部变量只在局部代码模块中被调用；
2.存储区域不同
成员变量存于堆内存的对象中。
局部变量存于栈内存的方法中。
3.初始化值不同
成员变量都有默认初始化值。
局部变量没有默认初始化值。
4.生命周期
成员变量随着对象的创建而存在，随着对象的消失而消失。
局部变量随着所属区域的执行而存在，随着所属区域的结束而释放。

示例1 创建人这个类，姓名性别年龄等属性，包含吃饭唱歌睡觉等行为；

class day01{
	public static void main(String[] args){
		person p=new person();
		p.eat();
		System.out.println(p.name);
		System.out.println(p.age);
	}
 }
 class person{
 		String name;
 		int age;
 		String sex;
 		public void eat(）{
 			System.out.println("吃饭");
 		}
 		public void sing(){
 				System.out.println("唱歌");
        }
        public void sleep(){
				System.out.println("睡觉");
        }
 }

6.2.2数据类型：可分为基本数据类型和引用数据类型

基本数据类型：传值（传常量在常量池中的地址）
引用数据类型：传址（对象在堆中的地址）
匿名对象：没有明确引用的对象
匿名对象使用：当对象只使用一次的时候

6.3构造函数

6.3.1构造函数的特殊性：

1.构造函数的函数名必须和所在类相同的名字
2.构造函数没有返回值类型，甚至连void也没有，没有返回值，但有隐藏的return；
3.构造函数实在创建一个对象使用new操作符是调用的。
4.构造函数有参数列表，所以可以重载
5.构造函数可以有权限修饰符
6.单个没有定义任何构造函数时会存在一个默认无参且隐藏的构造函数，建议将无参构造函数定义出来；
7.在数据域私有化时，有参构造函数中可以传参数，但是如果数据还需要修改和获取，则需要创建 set get函数。

6.3.2 创建对象的实际步骤;

1.创建对象的引用变量
2.创建对象 开辟空间 分配地址
3.对成员变量进行默认初始化（隐式初始化）
4.构造函数进栈 同时显示初始化
5.一句过早函数的内容 进行针对性初始化
6.构造函数弹栈 对象创建完成 将地址赋给应用变量。

6.4 静态基本概述及介绍

6.4.1静态基本概念

1.静态：静态关键字 “static”,作为静态修饰符，static修饰的变量称之为静态变量；static修饰的函数称为静态函数，static修饰的代码块称为静态代码块。
2.静态变量：又称为类变量，对象的共享属性；
3.静态函数：函数前用static关键字修饰的函数，成员函数只执行一次，不可被重写。

6.4.2静态变量与成员变量的区别

1.生命周期

静态变量从类的加载而产生，伴随类的消亡而消失。静态变量不可调用成员变量。
成员变量从对象的创建而产生，伴随对象的消亡而消失。

2.存储空间

静态变量存储于方法区中静态
成员变量存储于

3.作用域

4.别名

6.5继承

1.继承的关键字extends;
2.继承中子类继承父类的某些行为和属性，代码实现格式：

class zi extends fu{
		代码块
}

3.子类继承父类中可以被外界访问得到的，父类中私有化的行为和属性是不会被继承，而且父类中行为如果是抽象函数，子类中需要被重写，如果子类没有重写，则继续继承该抽象函数，子类中特有的函数是不会被外界访问的。

6.6多态

6.6.1多态基本概念

1.多态：事物在不同情况下所表现的形态，但是本质不变，在代码中表示多态：子类对象指向父类引用；

例如：父类 变量名=new 子类（）；Fu f=new Zi();

6.6.2多态的变量与函数的特点

1.成员变量在多态中特点

只能访问父类中的成员变量。

2.成员函数在多态中特点

①如果在子类中有函数的重写，则调用重写函数。
②如果子类中没有函数重写，则调用父类成员函数。
③ 在子类中没有函数重写的情况下如果父类中也没有调用的成员函数，报错。
④子类中特有的函数不可被调用。

3.静态变量在多态中的特点

只能访问父类中的静态变量。

4.静态函数在多态中的特点

只能访问父类中的静态函数；同时也间接证明了 静态函数不能被重写。

6.7 抽象类概念及其介绍

6.7.1抽象类基本概念

1.抽象概念：对于事物描述模糊不定，不清晰，不明白，不确定。
2.抽象函数：从代码方面讲，只有函数声明，没有函数体，当描述一类事物的时候，发现每个事物都有相同的功能，但每个事物执行的功能不同，当对这些事物进行父类抽取的时候，仅仅只保留该功能的声明，不用写出其代码块，此时，这给函数就是抽象函数，该函数的具体执行由子类所决定。
3. 抽象类：拥有抽象函数的类就是抽象类，但是，抽象类不一定包含抽象函数。
4. 继承抽象类的子类，可以实现抽象函数（抽象函数的重写写出其需要执行的代码块），也可以接着声明为抽象类。

6.7.2抽象类的特点

1.抽象类拥有构造函数，因为抽象类作为父类而存在，子类创建对象时，父类构造函数会进行一部分初始化，所以抽象函数有构造函数。
2.抽象类不能创建对象，因为抽象类创建出的对象，没有实际的函数体，创建的对象没有一个确定的东西，与对象的本质相违背，所以不能创建对象。
3.抽象类和一般类的区别是抽象类拥有抽象函数，抽象类有构造函数成员变量成员函数静态变量静态函数。
4.抽象函数不能和“final，static，private”关键字共存，原因：
final 修饰函数表示函数并不能被重写，final修饰类表示该类不能被继承
private 则表示该类被私有化，不能被访问，继承；
static 静态不存在被重写，静态必须是一个具体事物。

6.7.3特殊的抽象类

接口

1.接口（interface）：从代码上将接口的所有函数都是抽象函数，其
属性默认为 “ public static final 常量”，
行为默认为“ public abstract 抽象函数”。
2.接口的特点：

①解耦：降低耦合性： 向外界提供一套统一的标准 ，例如USB接口
②传参：（基本数据类型  引用数据类型   一段代码）
③对事物的拓展

6.8 内部类

内部类：在描述一个事物的时候，发现该事物中又有其他的事物，其他事物叫做内部类，该事物叫外部类。

例题1.
在这里插入图片描述

public class day02 {
	public static void main(String[] args){
		Rectangle s=new Rectangle();
		s.getWidth(3);
		s.getHeight(4);
		System.out.println(s.getArea(3,4));
		System.out.println(s.getPerimeter(3,4));
		
	}
}
class Rectangle{
	private double width;
	private double height;
	public void Rectangle(){
		this.width=1;
		this.height=1;
	}
	public double getWidth(double width){
		return this.width=width;
	}
	public double getHeight(double height){
		return this.height=height;
	}
	public double getArea(double width,double height){
		return width*height;
	}
	public double getPerimeter(double width,double height){
		return (width+height)*2;
	}
}

例题 2
在这里插入图片描述
代码

public class day03 {
	public static void main(String[] args){
		StopWatch sw=new StopWatch();
		sw.start();
		for(long i=0;i<100000000;i++);
		sw.end();
		System.out.println(sw.getElapsedTime());
	}
}
class StopWatch{
	private long startTime;
	private long endTime;
	public StopWatch(){
		this.startTime=System.currentTimeMillis();
	}
	public void start(){
		startTime=System.currentTimeMillis();
	}
	public void end(){
		endTime=System.currentTimeMillis();
	}
	public long getElapsedTime(){
		return (endTime-startTime);
	}
	public long getStartTime(){
		return this.startTime;
	}
	public long getEndTime(){
		return this.endTime;
	}
	
}

例题3
在这里插入图片描述代码：

public class day05 {
	public static void main(String[] args){
		Fan f=new Fan();
		f.isOn(true);
		f.setSpeed(3);
		f.setRadius(10);
		f.setColor("yellow");
		System.out.println(f.toString());
		Fan f1=new Fan();
		f1.isOn(false);
		f1.setSpeed(2);
		f1.setRadius(5);
		f1.setColor("blue");
		System.out.println(f1.toString());
		
		
	}
}
class Fan{
	private int SLOW=1;
	private int MEDIUM=2;
	private int FAST=3;
	private int speed=SLOW;
	private boolean on=false;
	private double radius=5;
	private String color="blue";
	public Fan(){
		
	}
	public String toString(){
		if(getOn()){
			return "风扇速度:"+speed+" 风扇半径 :"+radius+" 风扇颜色: "+color;
		}else{
			System.out.println("Fan is off!");
			return "风扇速度: "+speed+" 风扇半径:"+radius+" 风扇颜色:"+color;
		}
		
	}
	public void setSpeed(int speed){
		this.speed=speed;
	}
	public void isOn(boolean on){
		this.on=on;
	}
	public void setRadius(double radius){
		this.radius=radius;
	}
	public void setColor(String color){
		this.color=color;
	}
	public int getSpeed(){
		return this.speed;
	}
	public boolean getOn(){
		return this.on;
	}
	public double getRadius(){
		return this.radius;
	}
	public String getColor(){
		return this.color;
	}
}

例题4.
在这里插入图片描述代码如下：

import java.util.Scanner;

public class day06 {
	public static void main(String[] args){
		System.out.println("input three number a,b,c:");
		Scanner scanner=new Scanner(System.in);
		QuadraticEquation c=new QuadraticEquation(scanner.nextInt(),scanner.nextInt(),scanner.nextInt());
		c.delt();
	}
}
class QuadraticEquation{
	private int a;
	private int b;
	private int c;
	public QuadraticEquation(int a,int b,int c){
		this.a=a;
		this.b=b;
		this.c=c;
	}
	public int getA(){
		return this.a;
	}
	public int getB(){
		return this.b;
	}
	public int getC(){
		return this.b;
	}
	public double getDiscriminant(){
		return b*b-4*a*c;
	}
	public void delt(){
		if(getDiscriminant()>0){
			System.out.println("方程有两个根 ,第一个根为："+getRoot1()+" 第二个根为："+getRoot2());
			
		}else if(getDiscriminant()==0){
			System.out.println("方程有一个根！"+getRoot1());
		}else{
			System.out.println("方程没有实数解!");
		}
	}
	public double getRoot1(){
		 return (-b)-Math.sqrt(getDiscriminant())/(2*a);
	}
	public double getRoot2(){
		return (-b)-Math.sqrt(getDiscriminant())/(2*a);
		
	}
}

zmm0223

关注

3
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java面向对象

6.1面向对象概述及介绍6.1.1面向对象面向对象：是一种常见解决问题的思想，符合人们的思考习惯，可以将复杂的问题简单化，例如：下班回家吃饭，面向过程思想：买菜-洗菜-做饭-吃饭（亲力亲为）执行者；面向对象思想：叫外卖，下饭馆，女朋友做饭，（调用别人去做）指挥者。面向过程是最基本的解决思路，面向对象是基于面向过程的。6.2类与对象的关系类：是指一系列具有相似特征属性事物的统称。(...
复制链接

扫一扫