【Java SE】7.3类和对象

目录

1.封装

1.1封装的概念

1.2访问限定符

1.3封装扩展之包

1.3.1包的概念

1.3.2导入包中的类

1.3.3自定义包

1.3.4包的访问权限控制举例。

1.3.5常见的包

2.static成员

2.1再谈学生类

2.2static修饰成员变量

2.3static修饰成员方法

2.4static成员变量初始化

3.代码块

3.1代码块概念以及分类

3.2普通代码块

3.3构造代码块

3.4静态代码块

4.内部类

4.1内部类的分类

4.2内部类

4.2.1实例内部类

4.2.2静态内部类

4.3局部内部类

5.对象的打印


1.封装

1.1封装的概念

面向对象程序的三大特性:封装、继承、多态。 而类和对象阶段,主要研究的就是封装特性。何为封装呢? 简单来说,就是套壳屏蔽细节。

对于计算机使用者而言,不用关心内部核心部件,比如主板上线路是如何布局的,CPU内部是如何设计的等,用户只需要知道怎么开机,怎么通过键盘进行交互即可。因此,计算机厂商在出厂时,在外部套上壳子,将内部实现细节隐藏起来,仅仅对外提供开关机、鼠标以及键盘插口等,让用户可以与计算机进行交互即可。

封装:将数据和操作数据的方法进行有机结合,隐藏对象的属性和实现细节,仅对外公开接口来和对象进行交互。

1.2访问限定符

Java中主要通过类和访问权限来实现封装:类可以将数据以及封装数据的方法结合在一起,更符合人类对事物的认知,而访问权限用来控制方法或者字段能否直接在类外使用。Java中提供了四种访问限定符:

No范围privatedefaultprotectedpublic
1同一包中的同一类
2同一包中的不同类
3不同包中的子类
4不同包中的非子类

比如:

public:可以理解为一个人的外貌特征,谁都可以看到。

default:对于自己家族中(同一个包中)不是什么秘密,对于其他人来说就是隐私了。

private:只有自己知道,其他人都不知道。

【说明】

  • protected主要是用于在继承中
  • default权限指:什么都不写时的默认权限。
  • 访问权限除了可以限定类中成员的可见性,也可以控制类的可见性。
public class Computer {
private String cpu; // cpu
private String memory; // 内存
public String screen; // 屏幕
String brand; // 品牌---->default属性
public Computer(String brand, String cpu, String memory, String screen) {
this.brand = brand;
this.cpu = cpu;
this.memory = memory;
this.screen = screen;
}
public void Boot(){
System.out.println("开机~~~");
}
public void PowerOff(){
System.out.println("关机~~~");
}
public void SurfInternet(){
System.out.println("上网~~~");
}
}
public class TestComputer {
public static void main(String[] args) {
Computer p = new Computer("HW", "i7", "8G", "13*14");
System.out.println(p.brand); // default属性:只能被本包中类访问
System.out.println(p.screen); // public属性: 可以任何其他类访问
// System.out.println(p.cpu); // private属性:只能在Computer类中访问,不能被其他类访问
}
}

注意:一般情况下成员变量设置为private,成员方法设置为public。

1.3封装扩展之包
1.3.1包的概念

在面向对象体系中,提出来一个软件包的概念,即:为了更好的管理类,把多个类收集在一起成为一组,成为软件包。有点类似于目录。比如:为了更好的管理电脑中的歌曲,一种好的方式就是将相同属性的歌曲放在相同文件下,也可以对某个文件夹下的音乐进行更详细的分类。

在Java中也引入了包,包是对类、接口等的封装机制的体现,是一种对类或者接口等的很好的组织方式,比如:一个包中的类不想被其他的包中的类使用。包还有一个重要的作用:在同一个工程中允许存在相同名称的类,只要处在不同的包中即可。

1.3.2导入包中的类

Java中已经提供了很多种现成的类供我们使用。例如Date类:可以使用java.util这个包中的Date类

public class Test {
public static void main(String[] args) {
java.util.Date date = new java.util.Date();
// 得到一个毫秒级别的时间戳
System.out.println(date.getTime());
}
}

但是这种写法比较麻烦一些,可以使用import语句导入包。

import java.util.Date;
public class Test {
public static void main(String[] args) {
java.util.Date date = new java.util.Date();
// 得到一个毫秒级别的时间戳
System.out.println(date.getTime());
}
}

如果需要使用java.util中的其他类,可以使用import java.util*

import java.util.*;
public class Test {
public static void main(String[] args) {
Date date = new Date();
// 得到一个毫秒级别的时间戳
System.out.println(date.getTime());
}
}

但是我们更建议显示的指定要导入的类名,否则还是容易出现冲突的情况。

import java.util.*;
import java.sql.*;
public class Test {
public static void main(String[] args) {
// util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错
Date date = new Date();
System.out.println(date.getTime());
}
}
// 编译出错
Error:(5, 9) java: 对Date的引用不明确
java.sql 中的类 java.sql.Date 和 java.util 中的类 java.util.Date 都匹配

在这中情况下需要使用完整的类名

import java.util.*;
import java.sql.*;
public class Test {
public static void main(String[] args) {
java.util.Date date = new java.util.Date();
System.out.println(date.getTime());
}
}

可以使用import static 导入包中静态的方法和字段。

import static java.lang.Math.*;
public class Test {
public static void main(String[] args) {
double x = 30;
double y = 40;
// 静态导入的方式写起来更方便一些.
// double result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
double result = sqrt(pow(x, 2) + pow(y, 2));
System.out.println(result);
}
}

【注意事项】:import和C++的#include 差别很大。C++必须#include来引入其他的内容,但是Java不需要。import只是为了写代码的时候更方便。import更类似于C++的namespace和using。

1.3.3自定义包

基本规则:

  • 在文件的最上方加上一个package语句指定该代码在那个包中。
  • 包名需要尽量指定成唯一的名字,通常会是域名的颠倒形式。
  • 包名要和代码路径相匹配,例如创建com.bit.demo1的包,那么会存在一个对应的路径com/bit/demo1来存储代码。
  • 如果一个类没有package语句,则该类被放到一个默认包中。

操作步骤:

  1. 在IDEA中先创建一个包:右键src->新建->包
  2. 在弹出的对话框中输入包名,例如com.bit.demo1
  3. 在包中创建类,右键包名->新建->类,然后输入类名即可
  4. 此时,我们可以看到我们的磁盘上的目录结构已经被IDEA自动创建出来了。
  5. 同时,我们也看到了在新建的Test.Java文件的最上方,出现了一个package语句。
1.3.4包的访问权限控制举例。

 Computer类位于com.bit.demo1包中,TestComputer位置com.bit.demo2包中:

package com.bit.demo1;
public class Computer {
private String cpu; // cpu
private String memory; // 内存
public String screen; // 屏幕
String brand; // 品牌
public Computer(String brand, String cpu, String memory, String screen) {
this.brand = brand;
this.cpu = cpu;
this.memory = memory;
this.screen = screen;
}
public void Boot(){
System.out.println("开机~~~");
}
public void PowerOff()
System.out.println("关机~~~");
}
public void SurfInternet(){
System.out.println("上网~~~");
}
}
///
package com.bite.demo2;
import com.bite.demo1.Computer;
public class TestComputer {
public static void main(String[] args) {
Computer p = new Computer("HW", "i7", "8G", "13*14");
System.out.println(p.screen);
// System.out.println(p.cpu); // 报错:cup是私有的,不允许被其他类访问
// System.out.println(p.brand); // 报错:brand是default,不允许被其他包中的类访问
}
}
// 注意:如果去掉Computer类之前的public修饰符,代码也会编译失败
1.3.5常见的包
  1. java.lang;系统常用的基础类(String、object),此包从JDK1.1自动导入。
  2. java.lang.reflect;Java反射编程包。
  3. java.net;进行网络编程开发包。
  4. java.sql; 进行数据库开发的支持包。
  5. java.util;是Java提供的工具程序包。(集合类等)非常重要
  6. java.io;I/O编程开发包。

2.static成员

2.1再谈学生类
public class Student{
// ...
public static void main(String[] args) {
Student s1 = new Student("Li leilei", "男", 18, 3.8);
Student s2 = new Student("Han MeiMei", "女", 19, 4.0);
Student s3 = new Student("Jim", "男", 18, 2.6);
}
}

在Java中,被static修饰的成员,称之为静态成员,也可以称为类成员,其不属于某个具体的对象,是所有对象所共享的。

2.2static修饰成员变量

static修饰的成员变量,称为静态成员变量,静态成员变量最大的特征:不属于某个具体的对象,是所有对象所共享的。

【静态成员变量特性】

  1. 不属于某个具体的对象,是类的属性,所有对象共享的,不存储在某个对象的空间中。
  2. 既可以通过对象访问,也可以通过类名访问,但一般更推荐类名访问。
  3. 类变量存储在方法区中。
  4. 生命周期伴随着类的一生。
public class Student{
public String name;
public String gender;
public int age;
public double score;
public static String classRoom = "Bit306";
// ...
public static void main(String[] args) {
// 静态成员变量可以直接通过类名访问
System.out.println(Student.classRoom);
Student s1 = new Student("Li leilei", "男", 18, 3.8);
Student s2 = new Student("Han MeiMei", "女", 19, 4.0);
Student s3 = new Student("Jim", "男", 18, 2.6);
// 也可以通过对象访问:但是classRoom是三个对象共享的
System.out.println(s1.classRoom);
System.out.println(s2.classRoom);
System.out.println(s3.classRoom);
}
}
2.3static修饰成员方法

一般类中的数据成员都设置为private,而成员方法设置为public,那设置之后,Student类中的classRoom属性如何在类外访问呢?

public class Student{
private String name;
private String gender;
private int age;
private double score;
private static String classRoom = "Bit306";
// ...
}
public class TestStudent {
public static void main(String[] args) {
System.out.println(Student.classRoom);
}
}
编译失败:
Error:(10, 35) java: classRoom 在extend01.Student中是private访问控制。

那static属性应该如何访问呢?

Java中,被static修饰的成员方法称之为静态成员方法,是类的方法,不是某个对象所特有的。静态成员一般是通过静态方法来访问的。

public class Student{
// ...
private static String classRoom = "Bit306";
// ...
public static String getClassRoom(){
return classRoom;
}
}
public class TestStudent {
public static void main(String[] args) {
System.out.println(Student.getClassRoom());
}
}
输出:Bit306

【静态方法特性】

  1. 不属于某个具体的对象,是类方法。
  2. 可以通过对象调用,也可以通过类名.静态方法名(……)方式调用。
  3. 不能在静态方法中访问任何非静态成员变量。
public static String getClassRoom(){
System.out.println(this);
return classRoom;
}
// 编译失败:Error:(35, 28) java: 无法从静态上下文中引用非静态 变量 this
public static String getClassRoom(){
age += 1;
return classRoom;
}
// 编译失败:Error:(35, 9) java:无法从静态上下文中引用非静态变量age

4.静态方法中不能调用任何非静态方法,因为非静态方法有this参数,在静态方法中调用时候无法传递this引用

public static String getClassRoom(){
doClass();
return classRoom;
}
// 编译报错:Error:(35, 9)java;无法从静态上下文中引用过非静态方法 doClass()
2.4static成员变量初始化

注意:静态成员变量一般不会放在构造方法中来初始化,构造方法中初始化的是与对象相关的实例属性

静态成员变量的初始化分为两种:就地初始化和静态代码块初始化

1.就地初始化

就地初始化指的是:在定义时直接给出初始值

public class Student{
private String name;
private String gender;
private int age;
private double score;
private static String classRoom = "Bit306"; 
// ...
}

3.代码块

3.1代码块概念以及分类

使用{}定义的一段代码称之为代码块。根据代码块定义的位置以及关键字,又可以分为以下四种:

  • 普通代码块
  • 构造块
  • 静态块
  • 同步代码块
3.2普通代码块

普通代码块:定义在方法中的代码块

public class Main{
public static void main(String[] args) {
{ //直接使用{}定义,普通方法块
int x = 10 ;
System.out.println("x1 = " +x);
}
int x = 100 ;
System.out.println("x2 = " +x);
}
}
// 执行结果
x1 = 10
x2 = 100
3.3构造代码块

构造块:定义在类中的代码块(不加修饰符)。也叫:实例代码块。构造代码块一班用于初始化实例成员变量。

public class Student{
//实例成员变量
private String name;
private String gender;
private int age;
private double score;
public Student() {
System.out.println("I am Student init()!");
}
//实例代码块
{
this.name = "bit";
this.age = 12;
this.sex = "man";
System.out.println("I am instance init()!");
}
public void show(){
System.out.println("name: "+name+" age: "+age+" sex: "+sex);
}
}
public class Main {
public static void main(String[] args) {
Student stu = new Student();
stu.show();
}
}
// 运行结果
I am instance init()!
I am Student init()!
name: bit age: 12 sex: man
3.4静态代码块

使用static定义的代码块称之为静态代码块。一般用于初始化静态成员变量。

public class Student{
private String name;
private String gender;
private int age;
private double score;
private static String classRoom;
//实例代码块
{
this.name = "bit";
this.age = 12;
this.gender = "man";
System.out.println("I am instance init()!");
}
// 静态代码块
static {
classRoom = "bit306";
System.out.println("I am static init()!");
}
public Student(){
System.out.println("I am Student init()!");
}
public static void main(String[] args) {
Student s1 = new Student();
Student s2 = new Student();
}
}

【注意事项】

  • 静态代码块不管生成多少个对象,其只会执行一次。
  • 静态成员变量是类的属性,因此是在JVM加载类时开辟空间并进行初始化的。
  • 如果一个类中包含多个静态代码块,在编译代码时,编译器会按照定义的先后顺序依次执行(合并)。
  • 实例代码块只有在创建对象时才会执行。

4.内部类

当一个事物内部,还有一个部分需要一个完整的结构进行描述,而这个内部的完整结构又只是为外部事物提供服务,那么这个内部的完整结构最好使用内部类。在Java中,可以将一个类定义在另一个类或者一个方法的内部,前者成为内部类,后者成为外部类。内部类也是封装的一种体现。

public class OutClass {
class InnerClass{
}
}
// OutClass是外部类
// InnerClass是内部类

【注意事项】

  1. 定义在class类名{}花括号外部的,即使是在同一个文件里,都不能称为内部类。
public class A{
}
class B{
}
// A 和 B是两个独立的类,彼此之前没有关系

2.内部类和外部类共用一个java源文件,但是经过编译之后,内部类会形成单独的字节码文件。

4.1内部类的分类

先来看下,内部类都可以在一个类的那些位置进行定义。

public class OutClass {
// 成员位置定义:未被static修饰 --->实例内部类
public class InnerClass1{
}
// 成员位置定义:被static修饰 ---> 静态内部类
static class InnerClass2{
}
public void method(){
// 方法中也可以定义内部类 ---> 局部内部类:几乎不用
class InnerClass5{
}
}
}

根据内部类定义的位置不同,一般可以分为以下几种形式:

  1. 成员内部类(普通内部类:未被static修饰的成员内部类和静态内部类:被static修饰的成员内部类)
  2. 局部内部类(不谈修饰符)、匿名内部类
4.2内部类

在外部类中,内部类的定义位置与外部类成员所处位置相同,因此称为成员内部类。

4.2.1实例内部类

即未被static修饰的成员内部类。

public class OutClass {
private int a;
static int b;
int c;
public void methodA(){
a = 10;
System.out.println(a);
}
public static void methodB(){
System.out.println(b);
}
// 实例内部类:未被static修饰
class InnerClass{
int c;
public void methodInner(){
// 在实例内部类中可以直接访问外部类中:任意访问限定符修饰的成员
a = 100;
b =200;
methodA();
methodB();
// 如果外部类和实例内部类中具有相同名称成员时,优先访问的是内部类自己的
c = 300;
System.out.println(c);
// 如果要访问外部类同名成员时候,必须:外部类名称.this.同名成员名字
OutClass.this.c = 400;
System.out.println(OutClass.this.c);
}
}
public static void main(String[] args) {
// 外部类:对象创建 以及 成员访问
OutClass outClass = new OutClass();
System.out.println(outClass.a);
System.out.println(OutClass.b);
System.out.println(outClass.c);
outClass.methodA();
outClass.methodB();
System.out.println("=============实例内部类的访问=============");
// 要访问实例内部类中成员,必须要创建实例内部类的对象
// 而普通内部类定义与外部类成员定义位置相同,因此创建实例内部类对象时必须借助外部类
// 创建实例内部类对象
OutClass.InnerClass innerClass1 = new OutClass().new InnerClass();
// 上述语法比较怪异,也可以先将外部类对象先创建出来,然后再创建实例内部类对象
OutClass.InnerClass innerClass2 = outClass.new InnerClass();
innerClass2.methodInner();
}
}

【注意事项】

  1. 外部类中的任何成员都可以在实例内部类方法中直接访问。
  2. 实例内部类所处的位置与外部类成员位置相同,因此也受public、private等访问限定符的约束
  3. 在实例内部类方法中访问同名的成员时,优先访问自己的,如果要访问外部类同名的成员,必须:外部类名称.this同名成员来访问。
  4. 实例内部类对象必须在先有外部类对象的前提下创建。
  5. 实例内部类的非静态方法中包含了一个指向外部类对象的引用。
  6. 外部类中,不能直接访问实例内部类中的成员,如果要访问必须先要创建内部的对象。
4.2.2静态内部类

被static修饰的内部成员类称为静态内部类。

public class OutClass {
private int a;
static int b;
public void methodA(){
a = 10;
System.out.println(a);
}
public static void methodB(){
System.out.println(b);
}
// 静态内部类:被static修饰的成员内部类
static class InnerClass{
public void methodInner(){
// 在内部类中只能访问外部类的静态成员
// a = 100; // 编译失败,因为a不是类成员变量
b =200;
// methodA(); // 编译失败,因为methodB()不是类成员方法
methodB();
}
}
public static void main(String[] args) {
// 静态内部类对象创建 & 成员访问
OutClass.InnerClass innerClass = new OutClass.InnerClass();
innerClass.methodInner();
}
}

【注意事项】

1.在静态内部类中只能访问外部类的静态成员

2.创建静态内部类对象时,不需要先创建外部类对象。

4.3局部内部类
public class OutClass {
int a = 10;
public void method(){
int b = 10;
// 局部内部类:定义在方法体内部
// 不能被public、static等访问限定符修饰
class InnerClass{
public void methodInnerClass(){
System.out.println(a);
System.out.println(b);
}
}
// 只能在该方法体内部使用,其他位置都不能用
InnerClass innerClass = new InnerClass();
innerClass.methodInnerClass();
}
public static void main(String[] args) {
// OutClass.InnerClass innerClass = null; 编译失败
}
}

【注意事项】

  1. 局部内部类只能在所定义的方法体内部使用
  2. 不能被public 、static等修饰符修饰。
  3. 编译器也有自己独立的字节码文件,命名格式:外部类名字.class
  4. 几乎不会使用

5.对象的打印

public class Person {
String name;
String gender;
int age;
public Person(String name, String gender, int age) {
this.name = name;
this.gender = gender;
this.age = age;
}
public static void main(String[] args) {
Person person = new Person("Jim","男", 18);
System.out.println(person);
}
}
// 打印结果:day20210829.Person@1b6d3586

如果想要默认打印对象中的属性该如何处理呢?答案:重写toString方法即可。

public class Person {
String name;
String gender;
int age;
public Person(String name, String gender, int age) {
this.name = name;
this.gender = gender;
this.age = age;
}
@Override
public String toString() {
return "[" + name + "," + gender + "," + age + "]";
}
public static void main(String[] args) {
Person person = new Person("Jim","男", 18);
System.out.println(person);
}
}
// 输出结果:[Jim,男,18]

  • 22
    点赞
  • 14
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值