面向对象（上）
面向对象：封装，继承，多态
一.类与对象
1.类的定义
class 类名{
属性--成员变量；
行为--成员方法；
}
例如：package mm;
class class1 {
String name; //定义String类型变量name。成员变量
int age; //定义int类型变量。成员变量
String sex; //定义Sting类型变量。成员变量
//定义方法。成员方法
void read (){
System.out.println("大家好，我是"+name+",我在看书");
}
}
补：局部变量（与成员变量不同）
class class1 {
int age=55; //成员变量
//定义方法
void read (){
int age =66：//局部变量
System.out.println("大家好，我是"+name+",我在看书");
}
}
2.对象的创建与使用
A.方法1： 类名 对象名称 = null；
对象名称 = new 类名；
方法2.类名 对象名称 = new 类名（）；
package mm;
class class1 {
String name; //定义String类型变量name
int age; //定义int类型变量
String sex; //定义Sting类型变量
//定义方法
void read (){
System.out.println("大家好，我是"+name+",我在看书");
}
}
class ll{
public static void main(String[] args) {
class1 mm = new class1();//创建对象
}
}
B.对象属性或方法的访问:
对象名称.属性名
对象名称.方法名
class1 mm = new class1();
class1.name="小孩"；//对象名称.属性名，调用/访问属性
class1.read();//对象名称.方法名，调用/访问方法
3.对象的引用传递
package mm;
class class1 {
String name; //定义String类型变量name
int age; //定义int类型变量
//String sex; //定义Sting类型变量
//定义方法.成员方法
void read (){
System.out.println("大家好，我是"+name+",年龄"+age);
}
}
class ww{
public static void main(String[] args) {
class1 mm = new class1();
class1 nn = new class1();
mm=nn;
mm.name="小米";
mm.age=20;
nn.age=10;
mm.read();
nn.read();
}
}
4.四种控制符
1.private（私用）：当被private修饰是，方法只能被类中访问，getxxx与setxxx方法供private访问调用
2.protected(保护)：具有子类访问权限。如果类中属性或方法被protected修饰符修饰，则此类中属性或方法可以被同一包下的类使用，也可以被不同包下的子类使用，但不能被不同包下的其他类使用
3.public(公共)：具有公共访问权限。如果类中的属性或方法被public修饰，则此类中的属性或方法可以被任何类调用
4.default(默认)：具有包访问权限，如果类中属性或方法不使用public,protected,privete修饰符修饰时，则说明其具有包访问权限，具有包访问权限的属性或方法既可以被自己类中的方法使用也可以被同一包下的其他类使用，但不能被其他包中的类使用
| 序号 | 范围 | private | default | protected | public |
| 1 | 同一包中的同一类 | √ | √ | √ | √ |
| 2 | 同一包中的不同类 | √ | √ | √ | |
| 3 | 不同包的子类 | √ | √ | ||
| 4 | 不同包的非子类 | √ |
5.实参与形参
形参出现在 函数定义 中，在整个函数体内都可以使用， 离开该函数则不能使用。. 实参出现在 主调函数中，进入被调函数后，实参变量也不能使用 。. 形参和实参的功能是作数据传送。. 发生函数调用时， 主调函数把实参的值传送给被调函数的形参从而实现主调函数向被调函数的数据传送 。. 1.形参变量只有在被调用时才分配内存单元， 在调用结束时， 即刻释放所分配的内存单元 。. 因此，形参只有在函数内部有效。. 函数调用结束返回主调函数后则不能再使用该形参变量。. 2.实参可以是常量、变量、表达式、函数等， 无论实参是何种类型的量，在进行函数调用时，它们都必须具有确定的值， 以便把这些值传送给形参。.
package mm;
class class2 {
String name;
int age;
void speak(int a) {//形参，占位置
age=a;
System.out.println("年龄是"+age);
}
}
class hh{
public static void main(String[] args) {
class2 nn = new class2();//创建对象
nn.speak(18);//实参
二.封装性
package Learn;
class learn1 {
private String name;
private int age;
//reture的使用（访问器方法）
public String getName() {
return name;
}
public void setName (String name) {//一般方法也可以形参实参
this.name=name;
}
public int getAge() {
return age;
}
public void setAge (int age) {
if (age<=0){
System.out.println("输入错误");
}else {
this.age=age;
}
}
void read() {
System.out.println("我叫"+name+"今年"+age);
}
}
class mm {
public static void main(String[] args) {
learn1 kk = new learn1();
kk.setName("张三");
kk.setAge(-18);
kk.read();
}
}
注意：getName与setAge用于获取name与get属性的值
补：（访问器方法）reture的使用
private String name;
//reture的使用
public String getName() {
return name;
}
public void setName (String name) {//一般方法也可以形参实参
this.name=name;
三.构造方法
1.定义构造方法
注意：构造方法名必须与类名一致
构造方法不能有任何返回值
不能在构造方法中使用reture返回一个语句，但可以reture结束
例如：ackage mm;
class Class3 {
String name ;
int age;
//构造方法(也称构造器与一般方法属于两种东西）
public Class3(int a,String n){
age=a;
name=n;
}
void read(){
System.out.println("我叫"+name+"我今年"+age);
}
}
class Class4 {
public static void main(String[] args) {
Class3 zz = new Class3(18, "张三");//构造方法初始化赋值
zz.read();
}
}
2.构造方法重载（构造方法可以重载）
package mm;
class Class3 {
private String name ;
private int age;
//构造方法(也称构造器）
public Class3(int a,String n){
age=a;
name=n;
}
public Class3(int a){
age=a;
}
void read(){
System.out.println("我叫"+name+"我今年"+age);
}
}
class Class4 {
public static void main(String[] args) {
Class3 zz = new Class3(18, "张三");
zz.read();
}
}
四：this关键字
1.使用this关键字调用本类中的属性（成员变量）
package mm;
class Class3 {
private String name ;
private int age;
public Class3(int age,String n){
this.age=age;//调用属性
name=n;
}
public Class3(int a){
age=a;
}
void read(){
System.out.println("我叫"+name+"我今年"+age);
}
}
class Class4 {
public static void main(String[] args) {
Class3 zz = new Class3(18, "张三");
zz.read();
}
}
2.使用this关键字调用成员方法
package Learn;
class learn2 {
public void openMouth() {
........
}
public void read() {
this.openMouth();
}
3.调用构造方法package mm;
class Class5 {
String name;
int age;
Class5 (int a ){
age=a;
}
Class5(int a ,String b){//形参
this(a);（√）与super相同
//this.a=a(×)
name =b;
}
void sperk(){
System.out.println("我叫"+name+"今年"+age);
}
}
class mm{
public static void main(String[] args) {
Class5 nn = new Class5(18 ,"张三");//实参
//nn.age=18;
//nn.name="张三";
nn.sperk();
五.代码块
1.普通代码块（直接在方法或语句中定义代码块）
class dm {
public static void main(String[] args) {
int age =14;
System.out.println("这是普通代码块：age"+age);
}
}
2.构造代码块（直接在类中定义代码块）
class xx {
{
sout
}
}
例如：
package ww;
class dm {
int age =12;
{
System.out.println("这是构造代码块：age"+age);
}
}
六.static关键字
1.静态属性
package mm;
class Class3 {
private String name ;
private int age;
static String coutury ="中国";//静态属性（全局属性）
//构造方法(也称构造器）
public Class3(int a,String n){
age=a;
name=n;
}
void read(){
System.out.println("我叫"+name+"我今年"+age+"国家"+coutury);
}
}
class Class4 {
public static void main(String[] args) {
Class3 zz = new Class3(18, "张三");
Class3 ww = new Class3(19, "张四");
zz.read();
ww.read();2.成员变量与类变量（静态变量/属性）成员变量随着对象创建而存储，类变量随着类的创建而存在六.代码块1.构造代码class Person { { // 定义构造代码块 System.out.println("构造代码块"); } public Person() { // 定义构造方法 System.out.println("构造方法"); }
} public class ConstructorCodeBlockTest {
public static void main(String[] args) {
// 实例化对象 new Person(); new Person(); new Person()
2.静态方法（全局方法）
直接调用静态方法
例如：
package ww;
class dm {
private String name;//成员变量
private int age;
private static String school = "山东商务";//全局属性/静态属性
//构造方法
public dm(String name, int age) {
this.name = name;
this.age = age;
}
//成员方法
public void df() {
System.out.println("我的姓名" + name + "我的年龄" + age + "我的学校" + school);
}
//reture
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static String getSchool() {//静态方法，直接返回静态属性
return school;
}
public static void setSchool(String school) {//静态方法，直接返回静态属性
//this.getSchool()=school;
dm.school = school;
}
}
class uu{
public static void main(String[] args) {
dm yy2 = new dm("张三",12);
yy2.df();
dm yy3 = new dm("李思思",15);
yy3.df();
}
3.静态代码块
在 Java 类中，使用一对大括号包围起来的若干行代码被称为一个代码块，用 static 关键字 修饰的代码块称为静态代码块。
当类被加载时，静态代码块会执行，由于类只加载一次，因此静态 代码块只执行一次。
在程序中，通常会使用静态代码块来对类的成员变量进行初始化。
例如：
package ww;
class oo {
{
System.out.println("我是构造代码块");
}
static{
System.out.println("我是静态代码块");
}
//构造方法
public oo(){
System.out.println("我是构造方法");
}
}
class dd{
public static void main(String[] args) {
oo hh1=new oo();
oo hh2 =new oo();
oo h3 = new oo();
}
}
七.内部类
1.1.成员内部类
在 Java 中，允许在一个类的内部定义类，这样的类称作内部类，这个内部类所在的类称作外 部类。
根据内部类的位置、修饰符和定义的方式可分为：成员内部类、静态内部类、方法内部类。
我们下面将针对成员内部类进行讲解。 在一个类中除了可以定义成员变量、成员方法，还可以定义类，这样的类被称作成员内部类。
在成员内部类中，可以访问外部类的所有成员。 如果想通过外部类去访问内部类，则需要通过外部类对象去创建内部类对象，创建内部类对 24 象的具体语法格式如下
： 外部类名.内部类名 变量名 = new 外部类名().new 内部类名(); 我们来看一个程序，代码如下：
class Outer {
private int num = 4;
// 定义类的成员变量
// 下面的代码定义了一个成员方法，方法中访问内部类
public void test() {
Inner inner = new Inner();
inner.show();
}
// 下面的代码定义了一个成员内部类
class Inner { void show() {
// 在成员内部类的方法中访问外部类的成员变量
System.out.println("num = " + num); }
} }
public class InnerTest {
public static void main(String[] args) {
Outer outer = new Outer();//创建外部类对象
outer.test();
// 调用 test() 方法
Outer.Inner inner = new Outer().new Inner();//创建内部类对象（全局）
inner.show(); // 调用 show () 方法
2.静态内部类
如果不需要外部类对象与内部类对象之间有联系，那么可以将内部类声明位 static，使其成 为静态内部类。静态内部类可以有实例成员和静态成员，它可以直接访问外部类的静态成员，但 如果想访问外部类的实例成员，就必须通过外部类的对象去访问。
另外，如果在外部类外访问静 态内部类成员，则不需要创建外部类对象，只需创建内部类对象即可。
class Outer {
private static int num = 4;// 定义类的成员变量
// 下面的代码定义了一个成员方法，方法中访问内部类
public void test() { Inner inner = new Inner(); inner.show();
}
// 下面的代码定义了一个静态内部类
static class Inner {
void show() {
// 在成员内部类的方法中访问外部类的成员变量
System.out.println("num = " + num);
} } }
public class InnerTest {
public static void main(String[] args) {
Outer outer = new Outer(）// 创建外部类对象
outer.test();// 调用 test() 方法
Outer.Inner inner = new Outer.Inner();// 创建内部类对象
inner.show(); // 调用 show () 方
3.方法内部类
方法内部类是指在成员方法中定义的类，它与局部变量类似，作用域为定义它的代码块，因此 它只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。
class Outer { private int num = 4;
// 定义类的成员变量
// 下面的代码定义了一个成员方法，方法中定义内部类，并访问内部类
public void test() {
// 下面的代码定义了一个方法内部类
class Inner { void show() {
// 在成员内部类的方法中访问外部类的成员变量
System.out.println("num = " + num); }
}
// 创建方法（局部）内部类对象
Inner inner = new Inner(); inner.show();
}
}
public class InnerTest {
public static void main(String[] args)
{
Outer outer = new Outer(); // 创建外部类对象
outer.test(); // 调用 test() 方法
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步
· DeepSeek 开源周回顾「GitHub 热点速览」
· 物流快递公司核心技术能力-地址解析分单基础技术分享
· .NET 10首个预览版发布：重大改进与新特性概览！
· AI与.NET技术实操系列（二）：开始使用ML.NET
· 单线程的Redis速度为什么快？