Java基础系列（5）- 面向对象（上）

1|0类和对象

类(Class)和对象(Object)是面向对象的核心概念。

类是对一类事物的描述，是抽象的、概念上的定义
对象是实际存在的该类事物的每个个体，因而也称为实例(instance)

2|0java类及类的成员

属性(field)：对应类中的成员变量（也叫成员变量、域、字段）

方法(method)：对应类中的成员方法（也叫函数）

3|0内存解析

堆（Heap），此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。这一点在Java虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配。

栈（Stack），是指虚拟机栈。虚拟机栈用于存储局部变量等。局部变量表存放了编译期可知长度的各种基本数据类型（boolean、byte、char 、 short 、 int 、 float 、 long 、double）、对象引用（reference类型，它不等同于对象本身，是对象在堆内存的首地址）。方法执行完，自动释放。

方法区（Method Area），用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

4|0属性

语法格式：修饰符数据类型属性名=初始化值

说明1：修饰符：
- 常用的权限修饰符有：private、缺省、protected、public
- 其他修饰符：static、final (暂不考虑)
说明2：数据类型
- 任何基本数据类型 (如int、Boolean) 或任何引用数据类型。
说明3：属性名
- 属于标识符，符合命名规则和规范即可。

举例

public class Person{
	private int age; //声明private变量 age
    public String name = “Lila”; //声明public变量 name
}

4|1变量的分类：成员变量(属性)与局部变量

在方法体外，类体内声明的变量称为成员变量。

在方法体内部声明的变量称为局部变量。

4|2属性（成员变量） VS 局部变量

1|0相同点：

定义变量的格式：数据类型变量名 = 变量值
先声明，后使用
变量都有其对应的作用域

1|0不同点：

在类中声明的位置的不同：
1. 属性：直接定义在类的一对 {} 内
2. 局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
关于权限修饰符的不同：
1. 属性：可以在声明属性时，指明其权限，使用权限修饰符
2. 常用的权限修饰符：private、public、缺省、protected
默认初始化值的情况：
1. 属性：类的属性，根据其类型，都有默认初始化值
  1. 整型（byte、short、int、long）默认 0
  2. 浮点型（float、double）：0.0
  3. 字符型（char）：0 （或 '\u0000'）
  4. 布尔型（boolean）：false
  5. 引用数据类型（类、数组、接口）：null
2. 局部变量：没有默认初始化值
  1. 意味着，我们在调用局部变量之前，一定要显示赋值
  2. 特别地：形参在调用时，我们赋值即可
在内存中加载的位置
1. 属性：加载到堆空间中（static放在方法区）
2. 局部变量：加载到栈空间

5|0方法

5|1什么是方法(method、函数）:

方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中也称为函数或过程。

将功能封装为方法的目的是，可以实现代码重用，简化代码
Java里的方法不能独立存在，所有的方法必须定义在类里。

举例

public class Person {
	private int age;
	public int getAge() { //声明方法getAge()
		return age; 
	}
	public void setAge(int i) { //声明方法setAge
		age = i; //将参数i的值赋给类的成员变量age
	} 
}

5|2方法的声明格式

修饰符 返回值类型 方法名（参数类型 形参1, 参数类型 形参2, ….）｛
	方法体程序代码
	return 返回值; 
｝

其中：

修饰符：public, 缺省, private, protected等

返回值类型：

1. 没有返回值：`void`。通常，没有返回值的方法中，就不适用return，但是，如果使用的话，只能`return;`表示结束此方法的意思
2. 有返回值，声明出返回值的类型。与方法体中 `return返回值`搭配使用

方法名：属于标识符，命名时遵循标识符命名规则和规范，见名知意

形参列表：可以包含零个，一个或多个参数。多个参数时，中间用,隔开

返回值：方法在执行完毕后返还给调用它的程序的数据

return关键字的使用：

1. 使用范围：使用在方法体中
2. 作用：结束方法；针对有返回值类型的方法，使用 return 数据 方法返回所要的数据
3. 注意点：return 关键字后面不可以跟执行语句

练习题一：

Person类

class Person {

    String name;
    int age;
    /**
     * sex:1 表明是男性
     * sex:0 表明是女性
     */
    int sex;

    public void study() {
        System.out.println("studying");
    }

    public void showAge() {
        System.out.println("age:" + age);
    }

    public int addAge(int i) {
        age += i;
        return age;
    }
}

PersonTest类

/*
 * 要求：
 * (1)创建Person类的对象，设置该对象的name、age和sex属性，调用study方法，
 * 输出字符串“studying”，调用showAge()方法显示age值，
 * 调用addAge()方法给对象的age属性值增加2岁。
 * (2)创建第二个对象，执行上述操作，体会同一个类的不同对象之间的关系。
 * 
 * 
 */
public class PersonTest {
	public static void main(String[] args) {
		Person p1 = new Person();
		
		p1.name = "Tom";
		p1.age = 18;
		p1.sex = 1;
		
		p1.study();
		
		p1.showAge();
		
		int newAge = p1.addAge(2);
		System.out.println(p1.name + "的新年龄为：" + newAge);
		
		System.out.println(p1.age);//20
		
		//*************************
		Person p2 = new Person();
		p2.showAge();//0
		p2.addAge(10);
		p2.showAge();//10
		
		p1.showAge();
		
	}
}

练习题二：

/*
 * 2.利用面向对象的编程方法，设计类Circle计算圆的面积。
 */
//测试类
public class CircleTest {
	public static void main(String[] args) {
		
		Circle c1 = new Circle();
		
		c1.radius = 2.1;
		
		//对应方式一：
//		double area = c1.findArea();
//		System.out.println(area);
		
		//对应方式二：
		c1.findArea();
		
		
		//错误的调用
//		double area = c1.findArea(3.4);
//		System.out.println(area);
		
	}
}

//圆
class Circle{
	
	//属性
	double radius;
	
	//求圆的面积
	//方式一：
//	public double findArea(){
//		double area = Math.PI * radius * radius;
//		return area;
//	}
	
	//方式二：
	public void findArea(){
		double area = Math.PI * radius * radius;
		System.out.println("面积为：" + area);
	}
	
	//错误情况：
//	public double findArea(double r){
//		double area = 3.14 * r * r;
//		return area;
//	}
//	
}

练习题三：

/*
 * 3.1 编写程序，声明一个method方法，在方法中打印一个10*8 的*型矩形，在main方法中调用该方法。
 * 3.2 修改上一个程序，在method方法中，除打印一个10*8的*型矩形外，再计算该矩形的面积，
 * 并将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。
 * 
 * 3.3 修改上一个程序，在method方法提供m和n两个参数，方法中打印一个m*n的*型矩形，
 * 并计算该矩形的面积， 将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印。

 */
public class Exer3Test {
	public static void main(String[] args) {
		Exer3Test test = new Exer3Test();
		
		//3.1测试
//		test.method();
		
		//3.2测试
		//方式一：
//		int area = test.method();
//		System.out.println("面积为：" + area);
		
		//方式二：
//		System.out.println(test.method());
		
		//3.3测试
		int area = test.method(12, 10);
		System.out.println("面积为：" + area);
		
	}
	
	//3.1 
//	public void method(){
//		for(int i = 0;i < 10;i++){
//			for(int j = 0;j < 8;j++){
//				System.out.print("* ");
//			}
//			System.out.println();
//		}
//	}
	//3.2 
//	public int method(){
//		for(int i = 0;i < 10;i++){
//			for(int j = 0;j < 8;j++){
//				System.out.print("* ");
//			}
//			System.out.println();
//		}
//		
//		return 10 * 8;
//	}
	//3.3
	public int method(int m,int n){
		for(int i = 0;i < m;i++){
			for(int j = 0;j < n;j++){
				System.out.print("* ");
			}
			System.out.println();
		}
		
		return m * n;
	}
}

练习题四：

/*
 * 4. 对象数组题目：
定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。
 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
问题一：打印出3年级(state值为3）的学生信息。
问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息

提示：
1) 生成随机数：Math.random()，返回值类型double;  
2) 四舍五入取整：Math.round(double d)，返回值类型long。
 * 
 * 
 * 
 * 
 */
public class StudentTest {
	public static void main(String[] args) {
		
//		Student s1 = new Student();
//		Student s1 = new Student();
//		Student s1 = new Student();
//		Student s1 = new Student();
//		Student s1 = new Student();
//		Student s1 = new Student();
		
		//声明Student类型的数组
		Student[] stus = new Student[20];  //String[] arr = new String[10];
		
		for(int i = 0;i < stus.length;i++){
			//给数组元素赋值
			stus[i] = new Student();
			//给Student对象的属性赋值
			stus[i].number = (i + 1);
			//年级：[1,6]
			stus[i].state = (int)(Math.random() * (6 - 1 + 1) + 1);
			//成绩：[0,100]
			stus[i].score = (int)(Math.random() * (100 - 0 + 1));
		}
		
		//遍历学生数组
		for(int i = 0;i <stus.length;i++){
//			System.out.println(stus[i].number + "," + stus[i].state 
//					+ "," + stus[i].score);
			
			System.out.println(stus[i].info());
		}
		
		System.out.println("********************");
		
		//问题一：打印出3年级(state值为3）的学生信息。
		for(int i = 0;i <stus.length;i++){
			if(stus[i].state == 3){
				System.out.println(stus[i].info());
			}
		}
		
		System.out.println("********************");
		
		//问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
		for(int i = 0;i < stus.length - 1;i++){
			for(int j = 0;j < stus.length - 1 - i;j++){
				if(stus[j].score > stus[j + 1].score){
					//如果需要换序，交换的是数组的元素：Student对象！！！
					Student temp = stus[j];
					stus[j] = stus[j + 1];
					stus[j + 1] = temp;
				}
			}
		}
		
		//遍历学生数组
		for(int i = 0;i <stus.length;i++){
			System.out.println(stus[i].info());
		}
		
	}
}

class Student{
	int number;//学号
	int state;//年级
	int score;//成绩
	
	//显示学生信息的方法
	public String info(){
		return "学号：" + number + ",年级：" + state + ",成绩：" + score;
	}
	
}

优化

/*
 * 4. 对象数组题目：
定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。
 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
问题一：打印出3年级(state值为3）的学生信息。
问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息

提示：
1) 生成随机数：Math.random()，返回值类型double;  
2) 四舍五入取整：Math.round(double d)，返回值类型long。
 * 
 * 
 * 此代码是对StudentTest.java的改进：将操作数组的功能封装到方法中。
 * 
 */
public class StudentTest1 {
	public static void main(String[] args) {
		
		//声明Student类型的数组
		Student1[] stus = new Student1[20];  
		
		for(int i = 0;i < stus.length;i++){
			//给数组元素赋值
			stus[i] = new Student1();
			//给Student对象的属性赋值
			stus[i].number = (i + 1);
			//年级：[1,6]
			stus[i].state = (int)(Math.random() * (6 - 1 + 1) + 1);
			//成绩：[0,100]
			stus[i].score = (int)(Math.random() * (100 - 0 + 1));
		}
		
		StudentTest1 test = new StudentTest1();
		
		//遍历学生数组
		test.print(stus);
		
		System.out.println("********************");
		
		//问题一：打印出3年级(state值为3）的学生信息。
		test.searchState(stus, 3);
		
		System.out.println("********************");
		
		//问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
		test.sort(stus);
		
		//遍历学生数组
		test.print(stus);
		
	}
	
	/**
	 * 
	 * @Description  遍历Student1[]数组的操作
	 * @author shkstart
	 * @date 2019年1月15日下午5:10:19
	 * @param stus
	 */
	public void print(Student1[] stus){
		for(int i = 0;i <stus.length;i++){
			System.out.println(stus[i].info());
		}
	}
	/**
	 * 
	 * @Description 查找Stduent数组中指定年级的学生信息
	 * @author shkstart
	 * @date 2019年1月15日下午5:08:08
	 * @param stus 要查找的数组
	 * @param state 要找的年级
	 */
	public void searchState(Student1[] stus,int state){
		for(int i = 0;i <stus.length;i++){
			if(stus[i].state == state){
				System.out.println(stus[i].info());
			}
		}
	}
	
	/**
	 * 
	 * @Description 给Student1数组排序
	 * @author shkstart
	 * @date 2019年1月15日下午5:09:46
	 * @param stus
	 */
	public void sort(Student1[] stus){
		for(int i = 0;i < stus.length - 1;i++){
			for(int j = 0;j < stus.length - 1 - i;j++){
				if(stus[j].score > stus[j + 1].score){
					//如果需要换序，交换的是数组的元素：Student对象！！！
					Student1 temp = stus[j];
					stus[j] = stus[j + 1];
					stus[j + 1] = temp;
				}
			}
		}
	}
	
	
}

class Student1{
	int number;//学号
	int state;//年级
	int score;//成绩
	
	//显示学生信息的方法
	public String info(){
		return "学号：" + number + ",年级：" + state + ",成绩：" + score;
	}
	
}

5|3匿名对象的使用

理解：我们创建的对象，没有显示的赋给一个变量名，即为匿名对象

特征：匿名对象只能调用一次

public class InstanceTest {
	public static void main(String[] args) {
		Phone p = new Phone();
//		p = null;
		System.out.println(p);
		
		p.sendEmail();
		p.playGame();
		
		
		//匿名对象
//		new Phone().sendEmail();
//		new Phone().playGame();
		
		new Phone().price = 1999;
		new Phone().showPrice();//0.0
		
		//**********************************
		PhoneMall mall = new PhoneMall();
//		mall.show(p);
		//匿名对象的使用
		mall.show(new Phone());
		
	}
}

class PhoneMall{
	
	
	public void show(Phone phone){
		phone.sendEmail();
		phone.playGame();
	}
	
}


class Phone{
	double price;//价格
	
	public void sendEmail(){
		System.out.println("发送邮件");
	}
	
	public void playGame(){
		System.out.println("玩游戏");
	}
	
	public void showPrice(){
		System.out.println("手机价格为：" + price);
	}
	
}

5|4方法的重载(overload)

1|0重载的概念

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

1|0重载的特点

与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。

1|0重载示例

//返回两个整数的和
int add(int x,int y){return x+y;}
//返回三个整数的和
int add(int x,int y,int z){return x+y+z;}
//返回两个小数的和
double add(double x,double y){return x+y;}

5|5可变个数的形参

JavaSE 5.0 中提供了Varargs(variable number of arguments)机制，允许直接定义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可变的实参。

//JDK 5.0以前：采用数组形参来定义方法，传入多个同一类型变量

public static void test(int a ,String[] books);

//JDK5.0：采用可变个数形参来定义方法，传入多个同一类型变量

public static void test(int a ,String…books);

声明格式：方法名(参数的类型名 ...参数名)
可变参数：方法参数部分指定类型的参数个数是可变多个：0个，1个或多个
可变个数形参的方法与同名的方法之间，彼此构成重载（如果函数1一个参数，函数2一个参数+可变个数，传入一个参数，用函数1）
可变参数方法的使用与方法参数部分使用数组是一致的
方法的参数部分有可变形参，需要放在形参声明的最后
在一个方法的形参位置，最多只能声明一个可变个数形参

5|6方法参数的值传递机制

方法，必须由其所在类或对象调用才有意义。若方法含有参数：

形参：方法声明时的参数

实参：方法调用时实际传给形参的参数值

Java的实参值如何传入方法呢？

Java里方法的参数传递方式只有一种：值传递。即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。

形参是基本数据类型：将实参基本数据类型变量的数据值传递给形参
形参是引用数据类型：将实参引用数据类型变量的地址值传递给形参

1|0例题一

方法一：

public static void method(int a, int b){
    a = a * 10;
    b = b * 20;
    System.out.println(a);
    System.out.println(b);
    System.exit(0);
}

方式二：


public static void method(int a, int b) {  
        PrintStream ps = new PrintStream(System.out) {  
            @Override  
            public void println(String x) {  
                if ("a=10".equals(x)) {  
                    x = "a=100";  
                } else {  
                    x = "b=200";  
                }  
                super.println(x);  
            }  
        };  
        System.setOut(ps);  
}

1|0例题二

定义一个int型的数组：int[] arr = new int[]{12,3,3,34,56,77,432};让数组的每个位置上的值去除以首位置的元素，得到的结果，作为该位置上的新值。遍历新的数组。

错误答案：(只有第一次得时候arr[0]是12，之后都是1)

for(int i= 0；i < arr.length;i++){
	arr[i] = arr[i] / arr[0];   
}

正确答案：

//正确写法1
for(int i = arr.length – 1;i >= 0;i--){
	arr[i] = arr[i] / arr[0];
}
//正确写法2
int temp = arr[0];
for(int i= 0；i < arr.length;i++){
	arr[i] = arr[i] / temp;
}

5|7递归方法

递归方法：一个方法体内调用它自身。

方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。

例子一：计算1-100之间所有自然数的和

//计算1-100之间所有自然数的和
public int sum(int num){
	if(num == 1){
		return 1;
	}else{
		return num + sum(num - 1);
	} 
}

例子二：已知有一个数列：f(0) = 1, f(1) = 4, f(n+2) = 2 * f(n+1) + f(n)，其中n是大于0的证书，求f(10)的值

public int f(int n){
    if(n == 0){
        return 1;
    }else if(n == 1){
        return 4;
    }else{
      //return f(n + 2) - 2 * f(n + 1);   这样写有问题，n太多会栈空间溢出
        return 2 * f(n - 1) + f(n - 2);
    }
}

5|8封装与隐藏

Java中通过将数据声明为私有的(private)，再提供公共的（public）方法:getXxx()和setXxx()实现对该属性的操作，以实现下述目的：

隐藏一个类中不需要对外提供的实现细节；

使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作；
便于修改，增强代码的可维护性

1|0四种访问权限修饰符

对于class的权限修饰只可以用public和default(缺省)。

public类可以在任意地方被访问。
default类只可以被同一个包内部的类访问。

5|9构造器

构造器的特征

它具有与类相同的名称
它不声明返回值类型。（与声明为void不同）
不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值

构造器的作用：创建对象；给对象进行初始化

根据参数不同，构造器可以分为如下两类：

隐式无参构造器（系统默认提供）
显式定义一个或多个构造器（无参、有参）

注意

Java语言中，每个类都至少有一个构造器
默认构造器的修饰符与所属类的修饰符一致
一旦显式定义了构造器，则系统不再 提供默认构造器
一个类可以创建多个重载的构造器
父类的构造器不可被子类继承

public class PersonTest {
    public static void main(String[] args){
        // 创建类的对象: new + 构造器
        Person p = new Person();
        p.eat();

        Person p1 = new Person("Tom");
        System.out.println(p1.name);
    }
}

class Person{
    // 属性
    String name;
    int age;

    // 构造器
    public Person(){
        System.out.println("构造器1");
    }

    public Person(String n ){
        name = n;
        System.out.println("重载构造器2");
    }

    public Person(String n, int a){
        name = n;
        age = a;
        System.out.println("重载构造器3");
    }
}

5|10JavaBean

JavaBean是一种Java语言写成的可重用组件。

所谓javaBean，是指符合如下标准的Java类：

类是公共的
有一个无参的公共的构造器
有属性，且有对应的get、set方法

5|11UML类图

5|12this的使用

使用this，调用属性、方法

class Person { // 定义Person类
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void getInfo() {
        System.out.println("姓名：" + name);
        this.speak();
    }

    public void speak() {
        System.out.println(“年龄：” + this.age);
    }
}

使用this调用本类的构造器

class Person { // 定义Person类
    private String name;
    private int age;

    public Person() { // 无参构造器
        System.out.println("新对象实例化");
        // 这里有40行代码，为了不让其他构造器重复写这40行代码，于是其他构造器调用这个构造器
    }

    public Person(String name) {
        this(); // 调用本类中的无参构造器
        this.name = name;
    }

    public Person(String name, int age) {
        this(name); // 调用有一个参数的构造器
        this.age = age;
    }

    public String getInfo() {
        return "姓名：" + name + "，年龄：" + age;
    }
}

注意：

可以在类的构造器中使用"this(形参列表)"的方式，调用本类中重载的其他的构造器！
明确：构造器中不能通过"this(形参列表)"的方式调用自身构造器
如果一个类中声明了n个构造器，则最多有 n - 1个构造器中使用了 "this(形参列表)"
"this(形参列表)"必须声明在类的构造器的首行！
在类的一个构造器中，最多只能声明一个"this(形参列表)

5|13关键字：package、import

5|14package

package语句作为Java源文件的第一条语句，指明该文件中定义的类所在的包。(若缺省该语句，则指定为无名包)。

它的格式为：

package 顶层包名.子包名 ;

包对应于文件系统的目录，package语句中，用 “.” 来指明包(目录)的层次；

包通常用小写单词标识。通常使用所在公司域名的倒置：com.atguigu.xxx

JDK中主要的包介绍

1. java.lang----包含一些Java语言的核心类，如String、Math、Integer、 System和Thread，提供常用功能

2. java.net----包含执行与网络相关的操作的类和接口。

3. java.io ----包含能提供多种输入/输出功能的类。

4. java.util----包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。

5. java.text----包含了一些java格式化相关的类

6. java.sql----包含了java进行JDBC数据库编程的相关类/接口

7. java.awt----包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。

5|15import

为使用定义在不同包中的Java类，需用import语句来引入指定包层次下所需要的类或全部类(.*)。import语句告诉编译器到哪里去寻找类。

语法格式：

import 包名.类名;

注意

在源文件中使用import显式的导入指定包下的类或接口
声明在包的声明和类的声明之间。
如果需要导入多个类或接口，那么就并列显式多个import语句即可
举例：可以使用java.util.*的方式，一次性导入util包下所有的类或接口。
如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。
如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的
是哪个类。
如果已经导入java.a包下的类。那么如果需要使用a包的子包下的类的话，仍然需要导入。
import static组合的使用：调用指定类或接口下的静态的属性或方法

__EOF__

本文作者：😎
本文链接：https://www.cnblogs.com/dongye95/p/14852947.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！

posted @ 2021-06-05 16:01 dongye95 阅读(139) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

阅读排行：
· 阿里最新开源QwQ-32B，效果媲美deepseek-r1满血版，部署成本又又又降低了！
· 单线程的Redis速度为什么快？
· SQL Server 2025 AI相关能力初探
· AI编程工具终极对决：字节Trae VS Cursor，谁才是开发者新宠？
· 展开说说关于C#中ORM框架的用法！

公告

Java基础系列（5）- 面向对象（上）

发表于 2021-06-05 16:01阅读：139评论：0推荐：0

Java基础 Java基础

关注

跳至底部

昵称： dongye95
园龄： 6年10个月
粉丝： 108
关注： 12

+加关注

1|0类和对象

2|0java类及类的成员

3|0内存解析

4|0属性

4|1变量的分类：成员变量(属性)与局部变量

4|2属性（成员变量） VS 局部变量

1|0相同点：

1|0不同点：

5|0方法

5|1什么是方法(method、函数）:

5|2方法的声明格式

5|3匿名对象的使用

5|4方法的重载(overload)

1|0重载的概念

1|0重载的特点

1|0重载示例

5|5可变个数的形参

5|6方法参数的值传递机制

1|0例题一

1|0例题二

5|7递归方法

5|8封装与隐藏

1|0四种访问权限修饰符

5|9构造器

5|10JavaBean

5|11UML类图

5|12this的使用

5|13关键字：package、import

5|14package

5|15import

公告

😎

Java基础系列（5）- 面向对象（上）

搜索

常用链接

随笔档案