本文深入解析Java中的类与对象概念，涵盖构造器、this关键字、包与导入、访问权限修饰符及数据封装等核心主题，通过实例演示如何正确封装数据。
这里写自定义目录标题
第11章 类与对象详解（一）
01 练习
-
1
tips:
快捷键Alt + Shift + s -->Generate Constructor using FieldsGenerate Constructor using Fields
直译：使用字段生成构造
1.2.
class Circle {
double radius;
//按住Alt + Shift + S
public Circle(double aRadius) {
super();
radius = aRadius;
}
public double getArea() {
return Math.PI * radius * radius;
// return radius;
}
}
public class Day091 {
public static void main(String[] args) {
Circle c = new Circle(3.0);
System.out.println(c.getArea());
Circle c2 = new Circle(2.0);
System.out.println(c2.getArea());
}
}
02 this关键字
2.1
class Animal {
String name;
int age;
//aName,aAge是显示参数
//每个构造器都有一个隐式参数this
public Animal(String aName,int aAge){
name = aName;
age = aAge;
}
public void say(){
System.out.println("我叫" + name);
System.out.println("我今年" + age + "岁了");
}
}
public class Da092 {
public static void main(String[] args) {
Animal a1 = new Animal("pet", 2);
a1.say();
}
}
2.2
class Animal {
String name;
int age;
//aName,aAge是显示参数
// public Animal(String aName,int aAge){
// name = aName;
// age = aAge;
//
// }
//aName,aAge是显示参数
//每个构造器都有一个隐式参数this
//this代表当前被创建的对象
public Animal(String aName,int aAge){
// name = aName;
// age = aAge;
this.name = aName;
this.age = aAge;
System.out.println(this); //地址
}
public void say(){
System.out.println("我叫" + name);
System.out.println("我今年" + age + "岁了");
}
}
public class Da092 {
public static void main(String[] args) {
Animal a1 = new Animal("pet", 2);
System.out.println(a1); //地址
a1.say();
}
}
2.3
例2.3.1
class Animal {
String name;
int age;
//aName,aAge是显示参数
// public Animal(String aName,int aAge){
// name = aName;
// age = aAge;
//
// }
//aName,aAge是显示参数
//每个构造器都有一个隐式参数this
//this代表当前被创建的对象
public Animal(String aName,int aAge){
// name = aName;
// age = aAge;
this.name = aName;
this.age = aAge;
System.out.println(this); //地址
}
public void say(){
System.out.println("我叫" + name);
System.out.println("我今年" + age + "岁了");
}
}
public class Da092 {
public static void main(String[] args) {
Animal a1 = new Animal("pet", 2);
System.out.println(a1); //地址
a1.say();
Animal a2 = new Animal("kitty",3);
System.out.println(a1); //地址
a2.say();
}
}
例2.3.2
class Animal {
String name;
int age;
//aName,aAge是显示参数
// public Animal(String aName,int aAge){
// name = aName;
// age = aAge;
//
// }
//aName,aAge是显示参数
//每个构造器都有一个隐式参数this
//this代表当前被创建的对象
public Animal(String name,int age){
// name = aName;
// age = aAge;
this.name = name;
this.age = age;
System.out.println(this); //地址
}
//在实例方法中， this代表调用此方法的对象
public void say(){
System.out.println("我叫" + this.name);
System.out.println("我今年" + this.age + "岁了");
}
}
public class Da092 {
public static void main(String[] args) {
Animal a1 = new Animal("pet", 2);
System.out.println(a1); //地址
a1.say();
Animal a2 = new Animal("kitty",3);
System.out.println(a1); //地址
a2.say();
}
}
例2.3.3
class Animal {
String name;
int age;
public Animal(){
}
public Animal(String name){
this.name = name;
}
//使用this关键字，构造器可以调用其他构造器
public Animal(String name,int age){
this(name); //调用上面的构造器
this.name = name;
}
//在实例方法中， this代表调用此方法的对象
public void say(){
System.out.println("我叫" + this.name);
System.out.println("我今年" + this.age + "岁了");
}
}
public class Da092 {
public static void main(String[] args) {
Animal a1 = new Animal("pet", 2);
System.out.println(a1); //地址
a1.say();
Animal a2 = new Animal("kitty",3);
System.out.println(a1); //地址
a2.say();
}
}
每个实例方法和构造器都有一个隐式参数this
在实例方法中this代表调用此方法的对象，在构造器中this代表当前被创建的对象。
使用this关键字，构造器可以调用其他构造器。
03 包和导入
java标准库中有很多类。这些类按照功能被划分为不同的包下。
java.lang包(java最基础的类)
java.util包(java工具类)
java.net包（网络相关的类）
Arrays类在java.util包下，那么Arrays类的全名就叫做java.util.Arrays。
3.1
import java.util.Arrays;
//快捷导入包ctrl+shift+o
public class Dday093 {
public static void main(String[] args) {
int[] arr = new int[10];
Arrays.fill(arr, 1);
for (int i : arr) {
System.out.println(i);
}
}
}
tips:
//快捷导入包ctrl+shift+o
3.2
java中，每个一类都必须有唯一的名字，为类命名就很麻烦。
包类似于文件夹，将类放在不同的包下，就可以避免命名冲突。
例如：
创建一个包：com.abc ，（全名为: com.abc.Foo）
再创建一个包：com.bbc (全名为：com.bbc.Foo)
再这两个包下分别创建一个Foo.java的class
这是可行的。
包一般是域名的倒置。
***查看工作空间
1.包类，单右，点选最下一项：Properties
2.查看 工作空间 地址 Location
ep:
D:\develop\eclipse-jee-mars-2-win32\workspace
D:\develop\eclipse-jee-mars-2-win32\workspace\Day09\src
tips:
- 打开eclipse type
04 访问权限修饰符
类的访问权限
类可以使用public修饰，指示这个类是公有的，可以被其他类访问（包括同一个包下的类和不同包下的类）。
如果类没有写public，那么它是包访问权限，只能被同一外包下的类访问。
成员变量和成员方法的访问权限
成员变量和成员方法有四种访问权限：
默认的（包访问权限）
public(公有的)
private(私有的)
protected(受保护的)
例一:
- 创建一个类，名为：Foo.java;
其所在包： com.abc
//包名com.abc.指示这个类位于com.abc包下
//注意必须和物理文件层次匹配
package com.abc;
//包访问权限
public class Foo {
int defaultV;
public int publicV;
private int privateV;
protected int protectedV;
void defaultF() {
}
public void publicF() {
}
private void privateF() {
}
protected void protectedF() {
}
}
- 创建另一个类，名为： Day094.java
其所在包： com.bbc
package com.bbc;
import com.abc.Foo;
public class Day094 {
public static void main(String[] args){
Foo f = new Foo();
System.out.println(f.publicV);
f.publicF();
System.out.println(f.privateV);
System.out.println(f.protectedV);
System.out.println(f.defaultV);
}
}
***可以看到
private
protected
default
都不能访问。
不适用访问权限修饰符，即为默认的访问权限，可以被同一个包下的其他类访问。
使用public修饰符，可以被任何类访问。
使用private修饰，只能在其声明的类中访问。
使用protected修饰，可以被其子类访问，包括同一包下的和不同包下的子类。还可以被同一个包下的无关类访问。
tips:
open type ctrl+shift+T
05 数据封装
对象包括状态和行为。对象将状态存储在实例变量中，并通过方法公开其行为，
方法对对象的内部状态进行操作，并作为对象到对象通信的主要机制。
隐藏内部状态并要求对象的方法执行所有交互称为数据封装，这是面向对象编程的基本原则。
tips:
Generate Constructor using Fields
直译：使用字段产生构造
例一：
1）创建Person类
public class Person {
//对所有的实例变量使用private
private String name;
private int age;
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
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 void info() {
System.out.println("我叫" + name);
System.out.println("我今年" + age + "岁了");
}
2) 创建主类
public class Day095 {
public static void main(String[] args) {
Person p = new Person("张三风", 20);
p.info();
}
}
--------------- Console---------------------
我叫张三风
我今年20岁了
3.) 封装起来
Person类不改变；
主类：
public class Day095 {
public static void main(String[] args) {
Person p = new Person("张三风", 20);
p.info();
//p.name = "李四四";
//封装起来
p.setName("李四四");
p.setAge(23);
p.info();
}
}
封装的作用
例如，年龄，如果不进行数据封装，修改如下后，会发现年龄可为非法数据。
1）Person类中改为：去掉age前的privae
public class Person {
//对所有的实例变量使用private
private String name;
int age;
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
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 void info() {
System.out.println("我叫" + name);
System.out.println("我今年" + age + "岁了");
}
}
2 ) 主类
改： 添加 p.age = -1;
结果运行，发现年龄可为 -1 。
正确的封装例子
1 ) Person类
public class Person {
//对所有的实例变量使用private,进行数据封装
private String name;
private int age;
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
//使用数据封装来限制年龄范围
// public void setAge(int age) {
// if (this.age <= 0 || this.age > 150) {
// System.out.println("非法的年龄");
// } else {
// this.age = age;
// }
// }
public void setAge(int age) {
if (age <= 0 || age > 150) {
System.out.println("非法的年龄");
} else {
this.age = age;
}
}
public void info() {
// System.out.println("我叫" + name); == System.out.println("我叫" + this.name); 一样
// System.out.println("我今年" + age + "岁了"); == System.out.println("我今年" + this.age + "岁了");一样
System.out.println("我叫" + this.name);
System.out.println("我今年" + this.age + "岁了");
}
}
2 ) 主类
public class Day095 {
public static void main(String[] args) {
Person p = new Person("张三风", 20);
p.info();
// p.name = "李四四";
p.setName("李四四");
p.setAge(23);
// p.age = -1;
p.setAge(-1);
p.info();
}
}
数据封装：对所有的实例变量使用private，并且提供getter和setter方法。避免外部直接访问和修改实例变量。
扫一扫
292
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
