java面向对象小结上

最新推荐文章于 2024-08-08 14:30:51 发布
最新推荐文章于 2024-08-08 14:30:51 发布
阅读量102 收藏
点赞数
文章标签： java 类 多态 抽象类 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44193041/article/details/105384138
版权

java 小结，内容面向对象上

关于重载

重载：如果同一个类中包含了两个或两个以上方法的方法名相同，但是形参列表不同，则称方法为重载。
比如计算圆和三角形的面积，都同时用area方法计算，这个时候就可以重载。

以下为代码

package hello;


public class The_area {
	public void Area(double a,double b,double c) {
		double p = (a+b+c)/2;
		double ans = Math.sqrt(p*(p-a)*(p-b)*(p-c));
		System.out.println("the area is " + ans);
	}
	public void Area(double r) {
		double ans = Math.PI*r*r;
		System.out.println("the area is " + ans);
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		The_area t = new The_area();
		t.Area(3,4,5);
		The_area c = new The_area();
		c.Area(3);
	}

}

关于隐藏和封装

访问控制符，拉的第一个可能略有点丑。。。

privatedefaultprotectedpublic
同一个类中VVVV
同一个包中VVV
子类中VV
全局范围内V

这个是控制符的访问级别

关于封装：指的是将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象内部信息，而是通过方法来实现对内部信息的操作和访问。

以下是一个关于封装的代码

package hello;

class Person{
	private String name;
	private int age;
	public void setName(String name) {
		if(name.length()>6 || name.length()<2) {
			System.out.println("您设置的人名不符合要求");
			return;
		}
		else {
			this.name = name;
		}
	}
	public String getName() {
		return name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		if(age>100 || age<0) {
			System.out.println("您设置的年龄不合法");
			return ;
		}
		else
			this.age = age;
	}
	
}


public class PersonTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		var p = new Person();
//		p.age = 10;该语句错误，因为类的成员变量被隐藏了，不能这么访问
		p.setAge(1000);
		System.out.println("the age is " + p.getAge());
		p.setAge(30);
		p.setName("weige");
		System.out.println("name: " + p.getName() + "age" + p.getAge());
	}

}

关于构造器

一般使用构造器来在创建对象时执行初始化，比如，以下，这样可以更好的实现封装

package hello;

class Me{
	public String name;
	public int age;
	public int high;
	public Me(String name,int age,int high) {
		this.name = name;
		this.age = age;
		this.high = high;
	}
}

public class About_me {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Me w = new Me("weige",19,180);
		System.out.printf("%s %d %d",w.name,w.age,w.high);
	}

}

关于继承

java的继承具有单继承的特点，即每个子类只有继承一个父类

以下是继承的实例，

示例1:

代码：

package hello;


class Animal{
	private void beat() {
		System.out.println("心脏跳动……");
	}
	public void breathe() {
		beat();
		System.out.println("吸一口气，吐一口气，呼吸中");
	}
}

class BBird extends Animal{
	public void fly() {
		System.out.println("我在天空自在的飞翔");
	}
}

class Wolf extends Animal{
	public void run() {
		System.out.println("我在陆地上快速的奔跑");
	}
}

public class InheritTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BBird b = new BBird();
		b.breathe();
		b.fly();
		Wolf w = new Wolf();
		w.breathe();
		w.run();
	}

}

子类继承父类示例2:
可以调用父类的构造器，来初始化

package win_java;


class Vehicle {
	double speed;
	String kind;
	String color;
	public Vehicle(double s,String k,String c) {
		speed = s;
		kind = k;
		color = c;
	}
	
	public void setKind(String kind) {
		this.kind = kind;
	}

	public void setColor(String color) {
		this.color = color;
	}

	public void setSpeed(double speed) {
		this.speed = speed;
	}
	public double getSpeed() {
		return speed;
	}
	public String getKind() {
		return kind;
	}
	public String getColor() {
		return color;
	}
	
}



class Car extends Vehicle{
	int passenger;
	
	Car(double s,String k,String c,int p) {
		super(s,k,c);
		passenger = p;
	}
	
	public void get_seats() {
		System.out.println("the car owns " + passenger + "seats");
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Car mycar = new Car(300,"卡车","red",5);
		mycar.setColor("black");
		mycar.setSpeed(350);
		System.out.println(mycar.getColor());
	}

}

调用父类构造器来初始化

package hello;

class Base{
	public double size;
	public String name;
	public Base(double size,String name)
	{
		this.size = size;
		this.name = name;
	}
	public double getSize() {
		return size;
	}
	public String getName() {
		return name;
	}
	
}



public class Sub extends Base{

	public String color;
	public Sub(double size,String name,String color)
	{
		super(size,name);
		this.color = color;
	}
	
	
	public String getColor() {
		return color;
	}


	public static void main(String[] args) {
		// TODO Auto-generated method stub
		var s = new Sub(5.6,"调试对象","红色");
		System.out.println(s.getSize() + s.getName() + s.getColor());
		
			
	}

}

多态

java引用变量有两个类型：一个是编译时类型，一个是运行时类型。编译时类型由声明该变量时使用的类型决定，而运行时类型由实际赋给该变量的对象决定。如果编译时类型和运行时类型不一致时出现多态现象，得注意。

package hello;

class BaseClass{
	public int book = 6;
	public void base() {
		System.out.println("父类的普通方法");
	}
	public void test() {
		System.out.println("父类被覆盖的方法");
	}
}

public class SubClass extends BaseClass{
	
	public String book ="java入门";
	public void test() {
		System.out.println("子类的覆盖父类的方法");
	}
	public void sub() {
		System.out.println("子类的普通方法");
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BaseClass bc = new BaseClass();
		System.out.println(bc.book);
		bc.base();
		bc.test();
//		编译时类型和运行时类型完全一样所以不存在多态
		SubClass sc = new SubClass();
		System.out.println(sc.book);
//		输出了java入门
//		从父类继承base方法
		sc.base();
//		执行当前类的test方法，此时多态发生，因为同时使用了父类，也运用了子类
		sc.test();
//		编译时和类型不一样，多态发生
		BaseClass pBc = new SubClass();
		System.out.println(pBc.book);
//		输出了6
		pBc.base();
//		父类的普通方法
		pBc.test();
//		输出了子类的覆盖父类的方法
		System.out.println();
	}

}

组合实现复用两种方式吧

way1

package hello;


class Animal{
	private void beat() {
		System.out.println("心脏跳动……");
	}
	public void breathe() {
		beat();
		System.out.println("吸一口气，吐一口气，呼吸中");
	}
}

class BBird extends Animal{
	public void fly() {
		System.out.println("我在天空自在的飞翔");
	}
}

class Wolf extends Animal{
	public void run() {
		System.out.println("我在陆地上快速的奔跑");
	}
}

public class InheritTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BBird b = new BBird();
		b.breathe();
		b.fly();
		Wolf w = new Wolf();
		w.breathe();
		w.run();
	}

}

way2

package hello;


class Animal{
	private void beat() {
		System.out.println("心脏跳动……");
	}
	public void breathe() {
		beat();
		System.out.println("吸一口气，吐一口气，呼吸中……");
	}
}

class Birdd{
	private Animal a;
	public Birdd(Animal a) {
		this.a = a;
	}
	public void breathe() {
		a.breathe();
	}
	public void fly() {
		System.out.println("我在天空自在的飞翔……");
	}
}

class Wolff{
	private Animal a;
	public Wolff(Animal a) {
		this.a = a;
	}
	public void breathe() {
		a.breathe();
	}
	public void run() {
		System.out.println("我在陆地上快速奔跑");
	}
}

public class CompositeTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		var a1 = new Animal();
		var b = new Birdd(a1);
		b.breathe();
		b.fly();
		var a2 = new Animal();
		var w = new Wolff(a2);
		w.breathe();
		w.run();
	}

}

抽象类

抽象方法必须使用abstract修饰符来定义，抽象类可以没抽象方法

注意：
总结就是：抽象类可用有得有失来总结，得就是，抽象类可以包含抽象方法，失就是抽象类不能用于创建实例。

抽象类示例

示例1
代码：

package hello;

abstract class Shape{
	double radius,length,width,height;
	abstract double vol();
	Shape(double r,double h){
		radius = r;
		height = h;
	}
	Shape(double l,double w,double h){
		length = l;
		width = w;
		height = h;
			
	}
}

class Circle extends Shape{
	Circle(double r,double h){
		super(r,h);
	}
	double vol() {
		return 3.1416*radius*radius*height;
	}
}

class Rectangle extends Shape{
	public Rectangle(double l,double w,double h) {
		// TODO Auto-generated constructor stub
		super(l,w,h);
	}
	double vol() {
		return length*width*height;
	}
	
}


public class AbstractClassDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		var c = new Circle(2, 3);
		System.out.println(c.vol());
		var r = new Rectangle(3, 2, 4);
		System.out.println(r.vol());
	}

}

示例2
代码：

package hello;

abstract class Commonn{
	public double price,amount;
	abstract double calculate();
	Commonn(double p,double a) {
		price = p;
		amount = a;
	}
}

class Summer extends Commonn{
	Summer(double price,double amount){
		super(price,amount);
	}
	double calculate() {
		return price*amount;
	}
}

class Winter extends Commonn{
	Winter(double price,double amount){
		super(price,amount);
	}
	double calculate() {
		return price*(amount+20);
	}
}

public class abst_learning {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Summer s = new Summer(0.49,125);
		System.out.println("summer " + s.calculate());
		Winter w = new Winter(0.49,125);
		System.out.println("Winter " + w.calculate());
	}

}

基础概念还是得多用，实际操作可能会出现不同的意想不到的结局，比如同一个package内不能存在名字相同的类，比如在同一个class 中不能用public修饰的细节，路漫漫其修远兮。。。bug慢慢理。。。

think-weige
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java面向对象基础实验小结_JAVA面向对象基础小结
weixin_31188325的博客
02-28 1517
JAVA基础知识JAVA的面向对象(obtion object)Java面向对象首先要理清对象和类的关系：1. 类是对象的模板，对象是类的体现；现在把一个类比较一张汽车设计图纸，对象比做刚按照这张图纸制造出来的汽车。2. 一个类有很多对象，对象不能改变类的内容。一张图纸能够造出很多汽车，，其中的一辆车进行了改装，但是没能改变设计图纸，所以后面制造出来的汽车还是没有受到影响。3.创造一个类(类名首字...
java面向对象ppt_java面向对象课件
weixin_28930859的博客
02-12 823
PPT内容这是java面向对象课件，包括了类和对象的关系，构造方法，对象创建的内存模型，Java中的关键字等内容，欢迎点击下载。第三章 面向对象基础本章要点类和对象的关系面向对象的思想子类实例化的过程对象的创建构造方法变量的初始化顺序对象创建的内存模型垃圾回收机制Java中的关键字this关键字static关键字主要内容类和对象的关系面向对象的思想( Object Oriented Prog...
JAVA面向对象小结——理论问题
frankDuanh的博客
11-01 205
1、什么是类和对象？什么是面向对象程序设计？ 2、局部变量、实例变量和静态变量（类变量）的定义？如何使用？区别？ 3、重载（Overload）和重写（Override）的区别？ 4、封装、继承、多态的定义？优缺点？ 5、抽象类和接口的定义？区别？分别什么时候使用？ 6、向上造型表现形式？ 7、static、final修饰的成员变量和成员方法各有什么用法？8、&amp;和&amp;&amp;，|和|...
Java面向对象总结
qq_45209073的博客
12-06 236
第二章：类和对象的创建 概念：面向对象就是把一个项目，一个事情分成更小的项目，或者说分成一个个更小的部分，每一部分负责什么方面的功能，最后再由这些部分组合而成为一个整体。 好处：面相对象更接近实物的本质，提高代码的复用更具有扩展性。 如何使用：通常是创建类的对象再给属性赋值。 构造方法：构造方法的名称和类名相同，没有返回值类型。 GO g=new GO(); 构造方法的重载：方法名相同，参数列表不同，这是构造方法的重载。 如果一个类中包含了两个或两个以上的方法，他们方法名相同，方法参数个数或者参数类型不同
Java面向对象总结＜二＞
lsq736158497的博客
02-26 66
文章目录面向对象1. 构造方法1.1 编译器提供的无参数构造方法1.2 用户提供构造方法之后的效果2. 封装【重点，规范】2.1 JavaBean规范封装2.2.1 权限修饰符2.2.2 私有化成员变量setter和getter方法完成2.2.3 this关键字解决就近原则问题2.2.4 JavaBean规范代码案例3. 局部变量和成员变量3.1 局部变量3.2 成员变量3.3 对比3.4 "零"值3.5 对象销毁 ==> JVM GC机制 面向对象 1. 构造方法 1.1 编译器提供的无参数构造方法
java 面向对象总结
qq_58055172的博客
05-21 226
java 面向对象 总结
oop复习
huang6677的博客
04-24 2051
1、面向对象、什么是对象、对象和类的关系 什么是面向对象：万事万物皆为对象 对象和类的关系：类是用来描述对象的 对象是根据类来创建的 对象：属性+功能 类：属性+方法 2、创建对象 以及使用对象中的属性和方法 类名 对象名 = new 类名(); 对象名.属性; 对象名.方法(); 3、重载:同类中方法名相同，参数列表不同，返回值类型可同可不同 调用重载方法时，根据参数决定具体使用的方法 ...
java面向对象的六原则一法则小结
08-31
以下是Java面向对象设计的六原则一法则的详细解释： 1. **单一职责原则 (Single Responsibility Principle, SRP)**： 单一职责原则指出，一个类或模块应只有一个改变的原因。这意味着一个类应该只负责一项任务，...
java面向对象File (I O)
03-14
### Java面向对象File I/O详解 #### 概述 在Java中，`File`类是进行文件和目录操作的基础。通过这个类，开发者能够轻松地处理文件系统中的各种任务，如创建、删除文件或目录，读取文件元数据等。本文将深入探讨如何...
面向对象小结
08-16
java语法个人学习的一个小总结，个人心得，分享日常学习的java
Java面向对象重要概念小结.docx
10-19
Java面向对象编程是Java语言的核心特性，它基于三个主要原则：封装、继承和多态。在Java中，面向对象的设计允许我们模拟现实世界中的对象和它们之间的交互，从而提高代码的可读性、可维护性和复用性。下面是对Java...
Python面向对象程序设计示例小结
09-19
在Python编程语言中，面向对象程序设计是一种重要的编程范式，它基于“对象”的概念，将数据和操作数据的方法封装在一起。下面我们将深入探讨Python中的类定义、实例化、继承以及私有变量等关键概念。 1. 类定义： ...
java语言学习之类的继承，多态，继承与组合
Danny_llp的博客
08-04 287
java语言学习(3) 一.类的继承 1.java只能有一个直接父类，实际上，java类可以有无限多个间接父类。 class Fruit extends Plant{...} class Apple extends Fruit{...} 2.方法的重写 遵循"两同两小一大"规则，“两同”：即方法名相同，形参列表相同；“两小”指的是子类方法返回值类型应该比父类方法返回值类型更小或相等，子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等。一大指的是子类方法的访问权限应该比父类方法的访问权限更大或相
C++ - 函数重载
jiaowenjie的专栏
08-06 313
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
时光不等人：java每日一练
m0_67187271的博客
08-05 1077
时光悄然流逝，不等人。技术亦不会自来门前，唯有勤奋学习，方能抓住时代的脉搏。
Spring事务
c1tenj2的博客
08-07 426
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
【SpringBoot】数据验证之分组校验
Jacker
08-05 387
下面通过示例演示分组校验。在上面的示例中，在@Validated注解中增加了{GroupA.class,Default.class}参数，表示对于定义了分组校验的字段使用GroupA校验规则，其他字段使用默认规则。@Length(min=20,max=30,message="必须在[20,30]")，groups={GroupA.class};@Length(min=30,max=40,message="必须在[30,40]",groups={GroupB.class})/**用户id**/
反射和注解
最新发布
supercool7的博客
08-08 222
反射的基本步骤包括获取Class对象、获取类的信息（构造函数、方法、字段等），然后通过Constructor、Method、Field等类的实例进行具体的操作。注解以@符号开头，通常紧跟着一个标识符，后面可以跟一些参数，用于给类、方法、字段等添加元数据信息，这些信息可以在编译时、运行时被读取和处理。通过Class类，可以获取类的构造函数、方法、字段等信息，而不需要在编译时确定这些信息。Spring、SpringBoot、Mybatis等框架中都大量使用了反射机制。此外，开发者还可以定义自己的注解，通过。
Java | Leetcode Java题解之第324题摆动排序II
m0_57195758的博客
08-06 335
Java | Leetcode Java题解之第324题摆动排序II
Java语言入门基础与面向对象编程
每一章末尾都有小结，帮助学习者巩固所学知识。 通过这个Java基础教程，新手可以逐步掌握Java编程的基础，为后续的深入学习打下坚实的基础。教程的内容丰富，适合想要系统学习Java编程的新手。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值