JAVA:面向对象++封装+继承【详细】

Pyside6实战:3种.ui文件加载方式对比(附完整代码示例) 本文深入解析Pyside6中3种.ui文件加载方式的优劣与性能优化策略,包括动态加载QUiLoader、预编译方案及混合策略。通过实测数据和完整代码示例,帮助开发者根据项目需求选择最优解,提升界面加载效率与内存管理。 阅读详情

一、创建对象

创建类和对象为num_1:

package mian;
//类为num_1
public class num_1 {
 
	int x=10;
	public static void main(String[] args) {
 
		// TODO Auto-generated method stub
		num_1 myObj = new num_1();
	    System.out.println(myObj.x);
	}

}

演示:

二、对象的属性

X在以上中是变量,它实际上是类的一个 属性。或者可以说类属性是类中的变量。

例如:创建一个名为 " num_2" 的类,具有两个属性:x和y:

public class num_2 {
 
	int x=1;
	int y=2;
	public sta
	}

2.1访问属性

可以通过创建类的对象并使用点语法 ( .) 来访问属性。示例将创建一个num_2的类,对象为num_2,并打印对象的y属性:

package mian;

public class num_2 {
 
	int x=1;
	int y=2;
	public static void main(String[] args) {
 
		// TODO Auto-generated method stub
		
		num_2 s=new num_2();//创建对象
		System.out.println(s.y);
		
	}

}

演示:

2.2修改属性

修改属性x的值为10:

package mian;

public class num_3 {
 
	int x; //创建属性
	public static void main(String[] args) {
 
		// TODO Auto-generated method stub
		num_3 s=new num_3();//创建对象
		s.x=10;//修改属性值为10
		System.out.println(s.x);//打印修改后的属性值
	}
}

也可以直接覆盖:

package mian;

public class num_3 {
 
	int x=5; //创建属性
	public static void main(String[] args) {
 
		// TODO Auto-generated method stub
		num_3 s=new num_3();//创建对象
		s.x=10;//修改属性值为10
		System.out.println(s.x);//打印修改后的属性值
	}

}

如果不想覆盖现有值,将属性声明为final:

package mian;

public class num_4 {
 
	final int x=5; //创建属性
	public static void main(String[] args) {
 
		// TODO Auto-generated method stub
		num_4 s=new num_4();//创建对象
		s.x=10;//修改属性值为10
		System.out.println(s.x);//打印修改后的属性值
	}

}

这样,如果再想要覆盖就会发生报错了。

三、方法(函数)

3.1什么是方法?

方法就是类似函数(不过在java中不叫函数,叫做方法),为什么要使用方法?重用代码:定义一次代码,多次使用。(就是其它语言的函数)。方法必须在类中声明。它是用方法的名称定义的,后跟括号()。Java 提供了一些预定义的方法,例如System.out.println(),但您也可以创建自己的方法来执行某些操作:

创建一个方法test:

public class num_5 {
 
	static void test() {
 
		System.out.println("川川菜鸟");
	}

调用定义的方法:

package mian;

public class num_5 {
 
	static void test() {
 
		System.out.println("川川菜鸟");
	}
	public static void main(String[] args) {
 
		// TODO Auto-generated method stub
		test();
	}

}

一个方法也可以多次被调用(可见方便性):

package mian;

public class num_5 {
 
	static void test() {
 
		System.out.println("川川菜鸟");
	}
	public static void main(String[] args) {
 
		// TODO Auto-generated method stub
		test();
		test();
		test();
	}

}

3.2方法单个参数

例如传入字符串:

package mian;

public class num_6 {
 
static void test(String name) {
 
	System.out.println("名字为:"+name);
}
	public static void main(String[] args) {
 
		// TODO Auto-generated method stub
		test("张三");
		test("李四");
	}

}

输出为:

名字为:张三
名字为:李四

同理也可以数字参数:

package mian;

public class num_7 {
 
static void test(int num) {
 
	System.out.println("数字为:"+num);
}
	public static void main(String[] args) {
 
		// TODO Auto-generated method stub
		test(2);
		test(3);
	}

}

输出为:

数字为:2
数字为:3

3.3方法多个参数

例如传入字符和整形:

package mian;

public class num_8 {
 
static void test(String name,int age) {
 
	System.out.println(name+"年龄为:"+age);
}
	public static void main(String[] args) {
 
		// TODO Auto-generated method stub
		test("张三",22);
		test("李四",20);
	}
}

输出为:

张三年龄为:22
李四年龄为:20

3.4return使用

void关键字表示该方法不应返回值。如果希望方法返回值,可以使用原始数据类型(如int、 char等)代替void,并return 在方法内部使用关键字。例如:

package mian;

public class num_9 {
 
static int test(int n) {
 
	return n;
}
	public static void main(String[] args) {
 
		// TODO Auto-generated method stub
		System.out.println((2));
	}

}

也可以传入多个值,例如求两数和:

package mian;

public class num_10 {
 
static int test(int n,int m) {
 
	return m+n;
}
	public static void main(String[] args) {
 
		// TODO Auto-generated method stub
		System.out.println(test(2,5));
	}
}

3.5方法中添加if

例如成年与否的判断:

package mian;

public class num_11 {
 
	static void checkAge(int age) {
 

	    if (age < 18) {
 
	      System.out.println("不幸的是,你未成年!");

	    } else {
 
	      System.out.println("恭喜成年!");
	    }
	}
	public static void main(String[] args) {
 
		checkAge(5);
		checkAge(20);

	}

}

演示:

3.6方法重载

使用方法重载,多个方法可以具有相同的名称和不同的参数,例如:

int myMethod(int x)
float myMethod(float x)
double myMethod(double x, double y)

完整例子如下,两种方法可以添加不同类型的数字:

package mian;

public class num_12 {
 
	static int sum(int x, int y) {
 
		  return x + y;
		}

		static double sum(double x, double y) {
 
		  return x + y;
		}

		public static void main(String[] args) {
 
		  int num1 =sum(2, 3);
		  double num2 = sum(3.14, 2.15);
		  System.out.println("int: " + num1);
		  System.out.println("double: " +num2);
		}
}

四、类的方法

定义一个方法,用以打印为本:

package mian;

public class num_13 {
 
//定义方法
static void test(){
 
	 System.out.println("川川帅哥");
}
	public static void main(String[] args) {
 
		// TODO Auto-generated method stub
		test();//调用方法
	}

}

4.1静态与非静态

经常会看到具有static或public 属性和方法的 Java 程序。static方法可以直接被调用,而public只能访问对象:

package mian;

public class num_14
{
 
		  // Static方法
		  static void StaticMethod()
		  {
 
		    System.out.println("static方法");
		  }`static方法
public方法
`
		  // Public 方法
		  public void PublicMethod() 
		  {
 
		    System.out.println("public方法");
		  }
		  // Main方法
		  public static void main(String[] args) 
		  {
 
		    StaticMethod(); //调用静态方法
		    num_14 my = new num_14();// 创建Main对象
		    my.PublicMethod(); //调用非静态punlic方法
		  }
}

执行为:

static方法
public方法

4.2使用对象访问方法

例如:创建类num_15 ,方法pr打印,tro方法自我结束, me对象。使用对象方法两个public方法。

package mian;

public class num_15 
{
 
	
	//打印方法
	public void pr()
	{
 
	    System.out.println("你好啊,世界!");
	}

	  // 速度这个方法
	  public void tro(String name)
	  {
 
	    System.out.println("我的名字叫做: " +name);
	  }

	  // 在main方法中,用main对象调用以上定义的方法
	  public static void main(String[] args)
	  
	  {
 
		  num_15  me = new  num_15 ();   // 创建对象
	    me.pr();      // 调用对象
	    me.tro("张三");     
	  }
}

执行:

你好啊,世界!
我的名字叫做: 张三

4.3多个类之间的调用

我们在一个类中创建方法,另一个类来调用。

num_16.java:

package mian;

public class num_16 {
 

	public void pr()
	{
 
	    System.out.println("你好啊,世界!");
	}

	  // 速度这个方法
	  public void tro(String name)
	  {
 
	    System.out.println("我的名字叫做: " +name);
	  }

}

创建num_17.java:

package mian;

public class num_17 {
 

	public static void main(String[] args) {
 
		// TODO Auto-generated method stub
		num_16 me = new num_16();
		me.pr();
		me.tro("川川");
	}

}

执行:

你好啊,世界!
我的名字叫做: 川川

五、构造函数

Java 中的构造函数是一种用于初始化对象的特殊方法。创建类的对象时调用构造函数。它可用于设置对象属性的初始值。跟其它的语言都差不多的。

例如:

package mian;

public class num_18 {
 
	int x;//设置属性
	//为 num_18 类创建一个类构造函数
	public num_18()
	{
 
		x=6;//初始化属性值
	}
	public static void main(String[] args) {
 
		// TODO Auto-generated method stub
		num_18 s=new num_18();//创建对象s
		System.out.println(s.x);
	}

}

执行:6

注意:构造函数名称必须与类名称匹配,并且它不能有 返回类型(如void)

5.1构造函数参数

构造函数也可以带参数,用于初始化属性。

以一个加法为例:

package mian;

public class num_19 {
 
	 int x;

	  public num_19(int y) {
 
	    x = y+2;
	  }
	public static void main(String[] args) {
 
		// TODO Auto-generated method stub
		num_19 s=new num_19(5);
		System.out.println(s.x);
	}

}

执行:7

5.2多个参数

同样也可以传入多个任意数量的参数,

package mian;

public class num_20 {
 
	int age;
	String name;
	float money;//声明属性
	
	public num_20(int nage,String nname,float nmoney)
	{
 
		age=nage;
		name=nname;
		money=nmoney; 
	}
	public static void main(String[] args) {
 
		// TODO Auto-generated method stub
		num_20 s=new num_20(20,"张三",1000);
		System.out.println("年龄为:"+s.age);
	}

}

执行:年龄为:20

六、修饰符

public关键字是访问修饰符,意味着它用于设置类、属性、方法和构造函数的访问级别。

修饰符可以分为两组:

  • 访问修饰符- 控制访问级别
  • 非访问修饰符- 不控制访问级别,但提供其他功能

6.1访问修饰符

修饰符描述
public任何其他类都可以访问该类
default就是默认的类,比如打印"hello"

default例子:

class hello {
 
  public static void main(String[] args) {
 
    System.out.println("你好世界");
  }
}

对于属性、方法和构造函数,可以使用以下之一:

修饰符描述
public所有类都可以访问该代码、f方法
private代码只能在声明的类中访问
protected该代码可在相同的包和子类中访问

protected例子(给后续继承会学,不着急):

class Person {
 
  protected String fname = "川川";
  protected String lname = "菜鸟";
  protected String email = "hello@doe.com";
  protected int age = 22;
}

class Student extends Person {
 
  private int graduationYear = 2022;
  public static void main(String[] args) {
 
    Student myObj = new Student();
    System.out.println("Name: " + myObj.fname + " " + myObj.lname);
    System.out.println("邮箱: " + myObj.email);
    System.out.println("年龄: " + myObj.age);
    System.out.println("年份: " + myObj.graduationYear);
  }
}

6.2非访问修饰符

修饰符描述
final该类不能被其他类继承
abstract该类不能用于创建对象

对于属性和方法,可以使用以下当中之一:

修饰符描述
final属性和方法不能被覆盖/修改
static属性和方法属于类,而不是对象
abstract只能在抽象类中使用,并且只能在方法上使用。该方法没有主体,例如 abstract void run();。主体由子类提供
transient序列化包含它们的对象时忽略属性和方法
synchronized方法一次只能被一个线程访问
volatile属性的值不会在线程本地缓存,并且总是从“主内存”中读取

6.3final

如果不想覆盖现有属性值,需要属性声明为final:

package mian;

public class num_21 {
 
	final int x=5;
	final int y=6;
	public static void main(String[] args) {
 
		// TODO Auto-generated method stub
		num_21 s=new num_21();
		s.x=10;//覆盖
		s.y=9;//覆盖
		System.out.println(s.x);//会报错
	}

}

6.4static

方法static意味着可以在不创建类的对象的情况下访问它,不像public(需要创建对象才能访问):

package mian;

public class num_22 {
 
	//static方法
	 static void pr() {
 
		    System.out.println("川川");
		  }
	 //public方法
	 public void xue() {
 
		 System.out.println("菜鸟");
	 }
	 
	public static void main(String[] args) {
 
		// TODO Auto-generated method stub
		pr();//直接访问
		num_22 s=new num_22();//创建方法s
		s.xue();//访问s对象的方法;
	}

}

执行:

川川
菜鸟

6.5abstract

abstract方法属于一个类abstract,它没有主体。主体由子类提供。

编写抽象类num_23.java:

package mian;


//抽象类
abstract class Main {
 
	  public String name = "川川";
	  public int age = 24;
	  public abstract void study(); // 抽象方法
	}


//再定义子类
class num_23 extends Main {
 
	  public int graduationYear = 2022;
	  public void study() {
  
	  System.out.println("终身学习"); 
	  }
	}

编写主程序num_24.java:

package mian;

public class num_24 {
 

	public static void main(String[] args) {
 
		// TODO Auto-generated method stub
		num_23 s=new  num_23();//创建对象
		System.out.println("名字为:"+s.name);
		System.out.println("年龄为:"+s.age);
		s.study(); //调用抽象方法
		
	}

}

执行:

名字为:川川
年龄为:24
终身学习

七、封装

封装就是要确保对用户隐藏数据的保护,封装需要确保:

  • 将类变量/属性声明为private
  • 提供公共get 和set方法来访问和更新private 变量的值

在上一节,我们指导private变量只能在同一个类中访问(外部类无法访问它)。但是,如果我们提供公共的get和set方法,就可以访问它们。get方法返回变量值,set方法设置该值,两者的语法都是以getor开头set,后跟变量名,第一个字母大写。

person.java:

package mian;

public class person {
 
	private String name; 
	//取出name
	public String getName() {
 
	    return name;
	  }

	 public void setName(String newName) {
 
		    this.name = newName;
		  }
}

其中:this关键字用于引用当前对象。但是,由于name变量声明为private,我们 无法从此类外部访问它。

package mian;

public class main {
 

	public static void main(String[] args) {
 
		// TODO Auto-generated method stub
		person s=new person();//创建对象
		s.name="张三"; //修改.会报错。
		System.out.println(s.name); //访问。会报错。
		
	}
}

直接访问就会报错。如果变量被声明为public,就会可以访问到了

如果不修改为public,可以通过方法来修改:

package mian;

public class main {
 

	public static void main(String[] args) {
 
		person s=new person();//创建对象
		s.setName("川川"); //修改
		System.out.println(s.getName()); //访问
	}
}

执行:

为什么要封装?

  • 更好地控制类属性和方法
  • 类属性可以设为只读(如果只使用get方法)或只写(如果只使用set方法)
  • 灵活:程序员可以更改代码的一部分而不影响其他部分
  • 提高数据的安全性

包分为两类:

  • 内置包(来自 Java API 的包)
  • 用户定义的包(创建自己的包)

8.1 内置包

Java API 是一个预先编写的类库,可以免费使用,包含在 Java 开发环境中。该库分为包和类。这意味着可以导入单个类(及其方法和属性),也可以导入包含属于指定包的所有类的整个包。

要使用库中的类或包,需要使用import 关键字:

import package.name.Class;   // 导入单个类
import package.name.*;   // 导入整个库

8.2导入一个类

最常见就是用户输入类,Scanner类:

import java.util.Scanner;

举个例子:使用nextLine()用于读取完整行

package mian;
import java.util.Scanner;
public class num_25 {
 

	public static void main(String[] args) {
 
		Scanner s = new Scanner(System.in);
	    System.out.println("请输入名字:");

	    String userName = s.nextLine(); //读取整行
	    System.out.println("名字为: " + userName);
	}

}

执行:

8.3导入包

要导入整个包,请以星号 ( *) 结束句子。例如下面的案例:

package mian;
import java.util.*;
public class num_25 {
 

	public static void main(String[] args) {
 
		Scanner s = new Scanner(System.in);
	    System.out.println("请输入名字:");

	    String userName = s.nextLine(); //读取整行
	    System.out.println("名字为: " + userName);
	}

}

执行:

8.4定义包

使用package关键字,例如:

package bao;

class test {
  
	  public static void main(String[] args) {
  
	    System.out.println("优快云:川川菜鸟!"); 
	  } 
	}

九、继承

在 Java 中,可以将属性和方法从一个类继承到另一个类。继承分为两大类:

  • subclass (child) - 从另一个类继承的类
  • superclass (parent) - 继承自的类

要从类继承,需要使用extends 关键字。继承格式:

class 父类 {
 
}
 
class 子类 extends 父类 {
 
}

例如下面案例:

package mian;

class SuperClass {
 
	  private int n; //属性
	  SuperClass(){
   //方法1
	    System.out.println("川川");
	  }
	  SuperClass(int n) {
   //传参的方法2
	    System.out.println("菜鸟");
	    this.n = n;
	  }
	}
// SubClass 类继承 SuperClass
class SubClass extends SuperClass{
 
  private int n; //属性
  
  SubClass(){
  // 自动调用父类的无参数构造器
    System.out.println("自动调用");
  }  
  
  public SubClass(int n){
  
    super(300);  // 调用父类中带有参数的构造器
    System.out.println("参数为:"+n);
    this.n = n;
  }
}
	
public class num_26{
 
  public static void main (String args[]){
 
    System.out.println("------SubClass 类继承------");
    SubClass sc1 = new SubClass();
    SubClass sc2 = new SubClass(100); 
    
  }
}

执行:

如果不希望其他类从某个类继承,请使用final关键字:

final class SuperClass {
 
  ...
}

class Car extends SuperClass {
 
  ...
}
Unreal5从入门到精通之Landscape地形系统 虚幻引擎 5 (UE5) 能够利用其强大的地形编辑工具套件创建大规模的地形世界。使用地形工具可以创建身临其境的户外地形,这些地形经过优化,可在多种不同设备上保持可播放的帧速率。 阅读详情

相关推荐

车道线检测1.0(Python+Opencv基础版)

车道线检测是指在道路上自动检测和识别车道线的过程。车道线是道路上的标记,用于指示车辆行驶的方向和位置。 通过对车道线进行检测和识别,自动驾驶和智能驾驶系统可以实现车辆的自动导航、车道保持、车道偏离警告等功能。

Dream_orz的博客 4265

java的超类

通过getGenericSuperclass方法可以获取当前对象的直接超类的 Type 是父类。超类(SuperClass):用java术语来讲,被继承的类称为超类(SuperClass),也有叫做父类,继承的类称为子类。 通过getGenericSuperclass方法可以获取当前对象的直接超类的 Type Java代码 复制代码 收藏代码 1.package cn.tz...

tao_wei162的博客 1296

Python自然语言处理 NLTK 库用法入门教程【经典】

@本文来源于公众号:csdn2299,喜欢可以关注公众号 程序员学府 本文实例讲述了Python自然语言处理 NLTK 库用法。分享给大家供大家参考,具体如下: 在这篇文章中,我们将基于 Python 讨论自然语言处理(NLP)。本教程将会使用 Python NLTK 库。NLTK 是一个当下流行的,用于自然语言处理的 Python 库。 那么 NLP 到底是什么?学习 NLP 能带来什么好处? ...

python函数基础教程 1万+

java基础——类、超类、子类

类、超类、子类 1 概念 //A 是 B 的子类 用关键字 extends 表示 classA extends classB{ } extends 表示正在构造的新类派生与一个已经存在的类 已经存在的类称为超类(superclass) 新构造的类称为子类(subclass) 子类比超类拥有更多的功能 继承绝对不会删除任何字段或方法,只会增加新方法或者修改方法 通过扩展超类定义子类的时候,只需要指出子类与超类的不同之处。 因此在设计类的时候,应该做的是将最一般的方法放在超类中,将更特殊的方法放在子类中

qq_40624650的博客 3199

【SpringCloud】5、Spring Cloud Gateway网关路由规则

Spring Cloud Gateway 创建 Route 对象时, 使用 RoutePredicateFactory 创建 Predicate 对象,Predicate 对象可以赋值给 Route。

JACKAL 3万+

1、初探 Tiny Machine Learning

Tiny Machine Learning(TinyML)是机器学习与嵌入式系统的融合领域,致力于在资源受限的微控制器上运行AI模型。本文介绍了机器学习基础、TinyML的核心概念、应用领域(如智能家居、工业物联网、医疗保健)、面临的挑战(如资源限制、模型压缩、数据质量),以及从硬件准备到模型部署的实践步骤。通过利用训练与推理的资源不对称性,可在PC上训练模型并部署至低功耗设备进行实时推理,推动边缘智能的发展。

loss4bartender的博客 125

super class java_java – 为什么叫super class方法?

class One {public void doThing(One o) {System.out.println("One");}}class Two extends One{public void doThing(Two t) {System.out.println("Two");}}public class Ugly {public static void main(String[] arg...

weixin_29147045的博客 358

RT-DETR算法优化改进:轻量级上采样CARAFE算子 | 注意力机制大作战

上采样操作CARAFE,具有感受野大、内容感知、轻量级、计算速度快等优点,引入RT-DETR二次创新;1)代替Upsample进行使用;

①答疑群聊服务;②YOLO大模型知识问答系统;③计算机视觉论文生成智能体; 1267

java-类的继承

类的继承表达的是“is a”的关系。 被继承的类叫父类、基类、超类。 继承得到的类叫子类、派生类。 一、类的继承的实现 1.结构: [public] class SubClass extends SuperClass{ //类体 } 2.解释: SubClass是SuperClass的直接子类,SubClass继承了(扩展了)SuperClass。 3.如果SuperClass是类A的子类,那么SubClass是类A的间接子类。 4.注意: (1)子类通常比父类有更多的变量和方法。

yaowei的博客 3082

请举手回答,LDO和DC-DC有什么不同?

文章目录1 LDO是什么2 LDO典型电路3 DC-DC是什么4 DC-DC典型电路5 LDO和DC-DC区别10.2.6 小结一下 大家好,我是记得诚。 DC-DC和LDO都是电源芯片,两者差异很大,用法也不同,这篇博客讲述LDO和DC-DC的一些差异,帮助更好的认识LDO和DC-DC并进行选型。 1 LDO是什么 LDO是low dropout regulator的简称,即低压差线性稳压器,这是相对于传统的线性稳压器来说的,传统的稳压器,输入比输出要高出很多,否则无法工作,LDO可能输入比输出高1~2V

记得诚 1万+

OpenClaw界面操作手册:命令行与交互模式的正确打开方式

"test": {"description": "运行项目的测试套件","prompt": "请执行项目的测试命令,并分析测试结果。如果有失败的测试,请提供修复建议。},"lint": {"description": "运行代码检查","prompt": "请运行代码检查工具,分析所有警告和错误,并提供修复建议。},"doc": {"description": "为当前文件生成文档","prompt": "请为当前打开的文件生成完整的API文档,包括函数说明、参数描述、返回值类型和使用示例。

gaoxiang_120的专栏 3150

Java面试:5.05号

一、基础部分 1、java三大特性,都有什么用,怎么实现的,哪里用到了? 封装、继承、多态。 封装:是指隐藏对象的属性和实现细节,仅对外提供公共访问方式。 好处:将变化隔离,便于使用,提高重用性,提高安全性。 封装原则:将不需要对外提供的内容都隐藏起来。把属性都隐藏,提供公共方法对其访问。 应用: 1、private关键字:是一个权限修饰符。用于修饰成员(成员变量和成员函数)被私有化的成员只在本类中有效。 常用之一:将成员变量私有化,对外提供对应的set , get方法对其进行访问。提高对数

一诺 369

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

JAVA基础:面向对象++封装+继承【超详细】

创建类和对象为num_1:

weixin_45536242的博客 593

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf:最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版,包括SDIO 接口的外设,SDIO 接口官方协议等。

程序逸的Java小心得,不足挂齿相互学习(1)

一天速成JAVA基础概念(1) 一.基础数据类型的分析.(所有顺序都是按照第一个数据类型顺序排列的) 基本数据类型: 1.byte short int long float double char boolean. 字节个数: 1 2 4 8 4 8 ...

qq_43265564的博客 154

Java基础面试题

Java基础面试题

何某某-低级 115

第一阶段面试题

一、JAVA基础 列出JAVA中所有基本数据类型,并说明这些数据类型占用的字节数?? 答案: java的原始数据类型,也可以叫java的基本数据类型,一共就8个,分别是:byte、short、int、long、boolean、char、float、double byte 1个字节 boolean 1个字节 char 2个字节 short 2个字节 int 4个字节 long 8个字节 float 4个字节 double 8个字节 2.continue和 break有什么区别? 答案: break和cont

dan_dan的博客 201

Java封装、继承、多态

指程序中定义的引用变量所指向对象的具体类型和通过该引用变量发出的方法调用在编译时并不确定,直到程序运行时才能确定,即一个引用变量到底会指向哪个类的实例对象,该引用变量发出的方法调用到底是在哪个类中实现的方法,必须等到程序运行时才能决定。a) 基于继承的实现机制主要表现在父类和继承该父类的一个或多个子类对某些方法的重写,多个子类对同一方法的重写可以表现出不同的行为。b) 基于接口的多态实现主要表现在指向接口的引用必须是指向了实现该接口的一个类的实例对象,在运行时,根据对象引用的实际类型来执行对应的方法。

yachaorui的博客 894

JAVA面向对象编程——描述一个人类(有姓名、年龄、生日等属性),并继承出子类

前言: 面向对象这个概念在很多语言中都有接触过,尤其在c++中这个概念就是整个语言的核心。那什么是面向对象?也许我们对它都有个似懂非懂的概念,但无法完全清晰的理解。本文先大概描述面向对象的概念,再通过一个例子来和大家一起认识学习java面向对象。 一、面向对象概述 面向对象是一种使用封装、继承、多态、抽象等思想进行软件的分析和开发的方法,而java就是一门面向对象编程的语言。 1. 对象和类...

杨丹的博客 1万+

java面向对象及三大特性:封装、继承、多态

一、面向对象 1、面向过程和面向对象 (1)面向过程:(代表:C) 注重步骤,因果关系----不需对象的提取和模型的建立 (2)面向对象:(代表:java) 注重对象,利用关系连接对象---将整个实现成抽象成一个个对象,特征作为属性,行为作为方法 【注】 C++:既支持面向过程,又支持面向对象, 一般说java和c++区别时,应提到面向对象和面向过...

qq_44641527的博客 229

Java语言三大特性:封装、继承、多态

在学习Java语言之前,可能都有接触过C语言。C语言是面向过程的一门语言,面向过程的语言讲究的是因果关系,由一个因果关系构成一个模块,再由此模块与另一个因果关系构成一个模块,所以由C语言写出来的程序的耦合度很高,扩展性很差。而Java继承了C语言的优点,同时也改进了C语言的缺点,Java是一门面向对象的语言,将现实世界中的实体分成一个个独立的个体(现实中的个体都是独立的,具有独立特),独立性好,耦合度低,扩展性强。这些优点是由于Java语言的三大特性。 一、封装性 (1)Java语言中的每个对象都相当于

m0_66088782的博客 1303

面向对象三大特性:封装、继承、多态

文章目录三种继承权限修改访问权限作用域嵌套和名字遮蔽基类和派生类的构造函数基类和派生类的析构函数继承时的对象内存模型多继承时的对象内存模型菱形继承、虚继承菱形继承虚继承 三种继承权限 下表汇总了不同继承方式对不同属性的成员的影响结果 继承权限/基类成员 public成员 protected成员 private成员 public继承 public protected 不可见 protected继承 protected protected 不可见 private继承 priv

kk阿彬 1702

面向对象程序设计 封装、继承、多态性的深坑_封装继承中遇到的问题

这样理解就舒服多了,我们完全可以从每一个局部来处理封装、继承、多态设计特性,不拘于顶层设计的自下向上(bottom-up)的编程,甚至可以从底层回溯、中层演变,可以封装就封装,可以继承就继承,可以多态就多态,不一定完整有序,但要顺时机而为,做到闭环有理,开环有据。通常情况是:项目分类是不确定的,即需要多少类和子类配合,怎么分类是最合理的安全的这些都是未知的。**封装、继承、多态是相对的,只在一个同一层面上。所有的实体对象也是相对的,在一个局部是实体对象,而对另一个外部确是一个类的元素,变成对象的对象。

2401_84978490的博客 1014

C++ 面向对象编程基础:基础常识、对象、类、封装、继承

/ C语言宏定义(预处理器)#define PI3.14159// C++ const常量(编译时)// C++11 constexpr(编译时常量表达式)

2301_80436820的博客 848

封装、继承、多态(面向对象编程中级)-------很重要

目录封装封装的作用封装的步骤继承继承的作用继承的格式:继承细节:注意点1:默认访问修饰符的特殊性注意点2:注意点3:注意点4:注意点5:注意点6:注意点7:继承的本质分析(重要) 封装 封装的作用 封装操作和我们利用遥控器调节音量控制电视机很类似 封装的步骤 person.salary=2000;//报错了因为salary是private的所以只能在本类使用 这里就体现出来封装的重要性,对于私有属性的数据不能随意更改和访问 package Java_base_study; public class

Myblog 1968

面向对象—封装 继承 多态[java][全面总结]

特征一:封装 基本概念 通常情况下测试类中可以对类中的成员变量进行访问(进行赋值),若赋值的数据合法但不合理时(比如卖家将自己售卖的商品的价格定为了一个负数),这个时候编译和运行都不会出错,但是输入的数据与现实不符 为了避免上述错误的发生,就需要对成员变量进行密封包装处理,这种密封包装成员变量的机制我们将它称为封装,换句话也就是说封装就是一种保证成员变量合理性的一种机制 封装的作用 保证类中成员变量的合理性 封装的具体实现(三步走) 第一步:私有化成员变量,使用private关键字修饰 第二步:设置共有

m0_57001006的博客 155

Java-SE-面向对象/java

今天上午复习了一下java面向对象部分,作下记录,下午复习java8的内容,也会发一篇博客。晚上还会继续发昨天没发的栈和队列的题解,以及树的相关知识Java 是一门面向对象的编程语言,核心思想是将现实世界的事物抽象为程序中的对象,通过封装、继承、多态等特性,实现代码的重用和扩展。本章将详细介绍 Java 面向对象编程的各个知识点。定义类: 创建对象: 4.1.3 注意事项 访问控制:成员变量通常使用 修饰,提供 的 Getter 和 Setter 方法,符合封装原则。 构造方法:用于初始化对象

2403_86942375的博客 1304
上一篇: 【无标题】
下一篇: 如何用 Java 几分钟处理完 30 亿个数据?
javaYY_
博客等级 码龄4年 148粉丝 69原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值