Java面向对象（类，访问权限修饰符，属性，变量）
1 面向对象与面向过程
面向对象和面向过程区别：
面向对象是相对于面向过程，面向过程指的功能行为，面向对象指将功能封装对象中，强调的是功能的对象。
例：将大象放入冰箱
- 面向过程的思想：
打开冰箱门 ====> 大象放进去 ====> 关闭冰箱门 - 面向对象的思想：
class 大象{
定义大象的属性(身高，体重，年龄...);
}
class 冰箱{
定义冰箱的属性(宽，高，体积...);
void 开门(){
开门的过程;
}
void 放(大象){
放入大象的过程;
}
void 关门(){
关门的过程;
}
}
面向对象三大特征：
- 封装;
- 继承;
- 多态。
面向对象的的两个核心：
- 类；
- 对象。
2 类和对象
面向对象的的两个核心：类和对象。
- 类：
类是对一类事物的描述，抽象的概念。
类是具有相同属性和行为对象的集合。 - 对象：
实际在该类事物中的每个个体，也称为一个实例。(万物皆对象)
对象是类中的一个实例。
类和对象区别：类是对象的抽象（类型），对象是类的实例（具体）。
2.1 类定义
1、语法：
[访问权限修饰符] [修饰符] class 自定义类名 {
类的成员(5个) 类中不能直接写逻辑代码
}
- 访问权限修饰符：public (公共，整个项目下能访问)，不加则默认 package 当前包下能访问；
- 修饰符：abstract (抽象) 修饰的类为抽象类，final (最终)修饰的类为最终类，两者不能同时出现，不要修饰符时可称为实体类；
- class：修饰类的一个关键字，代表这是一个类；
- 自定义类名：符合定义标识符的规则，首字母要大写，如果访问权限修饰符为 public，则此时的类名与 .java 文件名相同。一个 .java 文件下只能有一个 public 修饰的类。
2、类的五个成员
- 属性；
- 方法；
- 构造器(特殊的方法)；
- 代码块；
- 内部类。
public class Student {
// 1、属性
public String name=”张三”;
protected int age;
private String sex;
String address;
// 2、方法
public void study() {
System.out.println("学生在学习!");
}
// 3、构造器(特殊的方法)
public Student() {
}
// 4、代码块
{
int n = 10;
System.out.println(n);
}
// 5、内部类
class Dog{
}
}
2.2 访问权限修饰符
在 Java 编程语言中有四种权限访问控制符，这四种访问权限的控制符能够控制类中成员的可见性。
- public
(1) 定义：public 是公共的，被 public 所修饰的成员可以在任何类中都能被访问到。
(2) 修饰的成分：
public 能用来修饰类，在一个 java 源文件中只能有一个类被声明为 public，而且 public 修饰的类名与 .java 源文件的文件名必须相同，否则编译不能通过。
一个类作为外部类的时候只能被 public，或者默认访问修饰符所修饰。
但是一个类如果作为内部类的时候，则可以被四种访问修饰符所修饰，因为一个类作为内部类的时候，就作为外部类的一个成员属性了，因此可以有四种访问修饰符修饰，这是内部类和外部类的一个区别。后面再深究。
public 用来修饰类中成员(变量和方法)，被 public 所修饰的成员可以在任何类中都能被访问到。通过操作该类的对象能随意访问 public 成员。
public 在类的继承上的体现，被 public 所修饰的成员能被所有的子类继承下来。 - protected
（1）定义：protected 是受保护的，受到该类所在的包所保护。
（2）作用域：被 protected 所修饰的成员会被位于同一 package 中的所有类访问到。同时，被 protected 所修饰的成员也能被该类的所有子类继承下来。(注意：这里是指同一个 package 或者不同的 package 中的子类都能访问)。 - friendly(默认，缺省的不用写)
（1）定义：friendly 是友好的，即在成员的前面不写任何的访问修饰符的时候，默认就是友好的。所谓友好的，是对同一 package 的类友好。
（2）作用域：同一 package 中的所有类都能访问。被 friendly 所修饰的成员只能被该类所在同一个 package 中的子类所继承下来。(也就是说只有在同一个 package 中的子类才能访问到父类中 friendly 修饰的成员)。 - private
(1)定义：private 是私有的，即只能在当前类中被访问到，它的作用域最小。
2.3 类成员的使用
显示对象的使用：
- 创建类的对象(无参构造器)：
类名 对象 = new 类名(); - 调用属性：
对象.属性; - 调用方法：
对象.方法名(); - 本类中方法之间的调用：
直接调用方法名即可（隐藏 this 代表当前对象）：this.方法名()；
使用场景：用于多个对象，多个成员需要调用时使用。
隐匿对象的使用：
- 语法：
new 类名().方法();
或
new 类名().属性; - 使用场景：对象只创建一次时可以使用匿名对象，只调用一个成员时使用。
2.4 属性(类成员之一)
语法：
[访问权限修饰符] [修饰符] 类型 属性名;
- 访问权限修饰符: private(私有)，默认(同包)，protected(子类)，public(公共)；
- 修饰符：static(静态)，final(常量)，transient(不能被序列化)，volatile(线程安全)；
- 类型：
基本数据类型：
整型：byte、short、int、long；默认：0；
浮点型：float、double；默认：0.0；
字符型: char；默认：空格；
布尔型: Boolean；默认：false。
引用数据类型：
引用类型：类(java api 类，用户自定义类)，数组，接口等，默认：null。
2.5 变量
1、分类:
- 成员变量；
- 局部变量。
2、区别：
- 相同点：
(1)声明方式相同: 类型 变量名 = 初值；
注意：
成员变量可以加访问权限修饰符；
但是局部变量不能加访问权限修饰符，局部变量最多只能用 “final” 修饰符修饰为常量，其它修饰符不能使用。 - 不同点：
(1)声明的位置不同：
成员变量：声明在类中，方法外；
局部变量：方法中，或者为方法参数。
(2)在内存的存储位置不同：
局部变量：内存的栈中，必须初始化赋值；
成员变量：内存的堆中，成员变量在创建对象之后会有默认值。
(3)初始值不同：
成员变量在创建完对象之后，有初始值；
局部变量没有初始始值。
(4)生命周期不同：
成员变量随着对象的创建而创建，对象的销毁而销毁；
局部变量随着方法的调用需创建，方法调用结束而销毁。
3、补充：
作用域问题 :
原则：就近原则。
例如：成员变量与一个方法内的局部变量同时存在，在该方法中使用该变量时，就近原则优先使用方法内的局部变量。
4、练习：
创建一个动物类，声明昵称和年龄属性，并且定义一个方法显示动物信息：AnimalTest.java
/**
* @author zc
* @date 2021/10/20 11:13
* 动物测试类 AnimalTest
* main(String[] args)：程序运行主入口
*/
public class AnimalTest {
/**
* 程序运行主入口
* @param args 系统参数
*/
public static void main(String[] args) {
// new 新建一个 Animal 实例化对象 al
Animal a1 = new Animal();
// 给 al 属性 name 赋值
a1.name="小狗";
// 给 al 属性 age 赋值
a1.age=3;
// 调用 a1 的方法 show()
a1.show();
// 再次 new 新建一个 Animal 实例化对象 a2
Animal a2 = new Animal();
a2.name="小猫";
a2.age=1;
a2.show();
}
}
/**
* 动物类
*/
class Animal{
/**
* 属性 name,动物姓名
*/
String name;
/**
* 属性 age,动物年龄
*/
int age;
/**
* show()：方法显示动物的信息
*/
public void show() {
System.out.println(name+"===="+age);
}
}
程序运行显示：
小狗====3
小猫====1
扫一扫
3054
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
