安庆市住房和城乡建设局网站,可以注册的网站,廊坊网站建设技术外包,广告设计图素材 个人主页#xff1a;秋风起#xff0c;再归来~ 文章专栏#xff1a;javaSE的修炼之路 个人格言#xff1a;悟已往之不谏#xff0c;知来者犹可追 克心守己#xff0c;律己则安#xff01; 1、封装 1.1 封装的概念
面向对象程序三大… 个人主页秋风起再归来~ 文章专栏javaSE的修炼之路 个人格言悟已往之不谏知来者犹可追 克心守己律己则安 1、封装 1.1 封装的概念
面向对象程序三大特性封装、继承、多态。而类和对象阶段主要研究的就是封装特性。何为封装呢简单来说 就是套壳屏蔽细节。
比如对于电脑这样一个复杂的设备提供给用户的就只是开关机、通过键盘输入显示器USB插孔等让用 户来和计算机进行交互完成日常事务。但实际上电脑真正工作的却是CPU、显卡、内存等一些硬件元件。 对于计算机使用者而言不用关心内部核心部件比如主板上线路是如何布局的CPU内部是如何设计的等用户 只需要知道怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时在外部套上壳 子将内部实现细节隐藏起来仅仅对外提供开关机、鼠标以及键盘插孔等让用户可以与计算机进行交互即可。
封装将数据和操作数据的方法进行有机结合隐藏对象的属性和实现细节仅对外公开接口来和对象进行 交互
1.2 访问限定符
Java中主要通过类和访问权限来实现封装类可以将数据以及封装数据的方法结合在一起更符合人类对事物的认 知而访问权限用来控制方法或者字段能否直接在类外使用。Java中提供了四种访问限定符 比如
public可以理解为一个人的外貌特征谁都可以看得到
default: 对于自己家族中(同一个包中)不是什么秘密对于其他人来说就是隐私了
private只有自己知道其他人都不知道
【说明】
protected主要是用在继承中继承部分详细介绍
default权限指什么都不写时的默认权限
访问权限除了可以限定类中成员的可见性也可以控制类的可见性
注意一般情况下成员变量设置为private成员方法设置为public。
1.3 封装扩展之包 1.3.1 包的概念
在面向对象体系中提出了一个软件包的概念即为了更好的管理类把多个类收集在一起成为一组称为软件 包。有点类似于目录。比如为了更好的管理电脑中的歌曲一种好的方式就是将相同属性的歌曲放在相同文件 下也可以对某个文件夹下的音乐进行更详细的分类。 在Java中也引入了包包是对类、接口等的封装机制的体现是一种对类或者接口等的很好的组织方式比如一 个包中的类不想被其他包中的类使用。包还有一个重要的作用在同一个工程中允许存在相同名称的类只要处在 不同的包中即可。
1.3.2 导入包中的类
Java 中已经提供了很多现成的类供我们使用. 例如Date类可以使用 java.util.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) {Date date new 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 的包, 那么会存在一个对应的路径 com/bit/demo1 来存储 代码.
如果一个类没有 package 语句, 则该类被放到一个默认包中. 操作步骤
1. 在 IDEA 中先新建一个包: 右键 src - 新建 - 包 2. 在弹出的对话框中输入包名, 例如 Test.demo 3. 在包中创建类, 右键包名 - 新建 - 类, 然后输入类名即可. 4. 此时可以看到我们的磁盘上的目录结构已经被 IDEA 自动创建出来了 5. 同时我们也看到了, 在新创建的 Test.java 文件的最上方, 就出现了一个 package 语句 1.3.4 包的访问权限控制举例 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 学生类举例
学生类实例化三个对象s1、s2、s3每个对象都有自己特有的名字、性别年龄学分绩点等成 员信息这些信息就是对不同学生来进行描述的如下所示
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);}
} 假设三个同学是同一个班的那么他们上课肯定是在同一个教室那既然在同一个教室那能否给类中再加一个成 员变量来保存同学上课时的教室呢答案是不行的。 之前在Student类中定义的成员变量每个对象中都会包含一份(称之为实例变量)因为需要使用这些信息来描述 具体的学生。而现在要表示学生上课的教室这个教室的属性并不需要每个学生对象中都存储一份而是需要让所 有的学生来共享。在Java中被static修饰的成员称之为静态成员也可以称为类成员其不属于某个具体的对 象是所有对象所共享的。
2.2 static修饰成员变量
static修饰的成员变量称为静态成员变量静态成员变量最大的特性不属于某个具体的对象是所有对象所共 享的。
【静态成员变量特性】
1. 不属于某个具体的对象是类的属性所有对象共享的不存储在某个对象的空间中
2. 既可以通过对象访问也可以通过类名访问但一般更推荐使用类名访问
3. 类变量存储在方法区当中
4. 生命周期伴随类的一生(即随类的加载而创建随类的卸载而销毁)
public class Student{public String name;public String gender;public int age;public double score;public static String classRoom 306;// ...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.3 static修饰成员方法
一般类中的数据成员都设置为private而成员方法设置为public那设置之后Student类中classRoom属性如何 在类外访问呢
class Student{private String name;private String gender;private int age;private double score;private static String classRoom 306;public Student(String name, String gender, int age, double score) {this.name name;this.gender gender;this.age age;this.score score;}
}
public class TestStudent {public static void main(String[] args) {System.out.println(Student.classRoom);}
} 那static属性应该如何访问呢
Java中被static修饰的成员方法称为静态成员方法是类的方法不是某个对象所特有的。静态成员一般是通过 静态方法来访问的。
class Student{private String name;private String gender;private int age;private double score;private static String classRoom 306;public static String getClassRoom(){return classRoom;}public Student(String name, String gender, int age, double score) {this.name name;this.gender gender;this.age age;this.score score;}
}
public class TestStudent {public static void main(String[] args) {System.out.println(Student.getClassRoom());}
}
【静态方法特性】
1. 不属于某个具体的对象是类方法
2. 可以通过对象调用也可以通过类名.静态方法名(...)方式调用更推荐使用后者
3. 不能在静态方法中访问任何非静态成员变量
public static String getClassRoom(){System.out.println(this);return classRoom;
}// 编译失败Error:(35, 28) java: 无法从静态上下文中引用非静态 变量 thispublic 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()
5. 静态方法无法重写不能用来实现多态(此处暂时细讲后序多态位置详细讲解)。
2.4 static成员变量初始化
注意静态成员变量一般不会放在构造方法中来初始化构造方法中初始化的是与对象相关的实例属性
静态成员变量的初始化分为两种就地初始化 和 静态代码块初始化。
1. 就地初始化 就地初始化指的是在定义时直接给出初始值
public class Student{private String name;private String gender;private int age;private double score;private static String classRoom Bit306; // ...
2. 静态代码块初始化 那什么是代码块呢继续往后看 :) ~~~
3. 代码块 3.1 代码块的概念以及分类
使用 {} 定义的一段代码称为代码块。根据代码块定义的位置以及关键字又可分为以下四种
1、普通代码块
2、构造块
3、静态块
4、同步代码块这里不细讲
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 Person {//实例成员变量public String name;public String sex;public int age;//示例代码块{this.namezhangsan;this.sex男;this.age18;}Overridepublic String toString() {return Person{ name name \ , sex sex \ , age age };}public static void main(String[] args) {Person p1new Person();System.out.println(p1.toString());}
} 3.4 静态代码块
使 用 s t a tic 定 义 的 代 码 块 称 为 静 态 代 码 块 。
一 般 用 于 初 始 化 静 态 成 员 变 量 。
public class Person {//实例成员变量static String name;static String sex;static int age;//示例代码块static{namezhangsan;sex男;age18;}Overridepublic String toString() {return Person{ name name \ , sex sex \ , age age };}public static void main(String[] args) {Person p1new Person();System.out.println(p1.toString());}
}
注意事项
1. 静态代码块不管生成多少个对象其只会执行一次
2. 静态成员变量是类的属性因此是在JVM加载类时开辟空间并初始化的
3. 如果一个类中包含多个静态代码块在编译代码时编译器会按照定义的先后次序依次执行(合并) 4. 实例代码块只有在创建对象时才会执行
4. 内部类
当一个事物的内部还有一个部分需要一个完整的结构进行描述而这个内部的完整的结构又只为外部事物提供服 务那么这个内部的完整结构最好使用内部类。在 Java 中可以将一个类定义在另一个类或者一个方法的内部 前者称为内部类后者称为外部类。内部类也是封装的一种体现。
public class OutClass {class InnerClass{}
}// OutClass是外部类
// InnerClass是内部类
【注意事项】
1. 定义在class 类名{}花括号外部的即使是在一个文件里都不能称为内部类
public class A{}class B{}// A 和 B是两个独立的类彼此之前没有关系2. 内部类和外部类共用同一个java源文件但是经过编译之后内部类会形成单独的字节码文件
内部类的分类 先来看下内部类都可以在一个类的那些位置进行定义
根据内部类定义的位置不同一般可以分为以下几种形式
1. 成员内部类(普通内部类未被static修饰的成员内部类 和 静态内部类被static修饰的成员内部类)
2. 局部内部类(不谈修饰符)、匿名内部类
注意内部类其实日常开发中使用并不是非常多大家在看一些库中的代码时候可能会遇到的比较多日常开始中 使用最多的是匿名内部类。 public class OutClass {// 成员位置定义未被static修饰 ---实例内部类public class InnerClass1{}// 成员位置定义被static修饰 --- 静态内部类static class InnerClass2{}public void method(){// 方法中也可以定义内部类 --- 局部内部类几乎不用class InnerClass5{}}
} 4.1 实例内部类
即未被static修饰的成员内部类。
1. 外部类中的任何成员都可以在实例内部类方法中直接访问
public class OutClass {public int data11;private int data22;int data33;public static int data44;public void outMethodA(){System.out.println(data1:data1);}public static void outMethodB(){System.out.println(data4:data4);}//定义一个实例内部类class innerClass{//在实例内部类当中可以访问任意访问修饰限定符的成员//在实例内部类当中创建一个方法public void innerMethod(){// 在实例内部类中可以直接访问外部类中任意访问限定符修饰的成员data110;data220;data330;data440;outMethodA();outMethodB();System.out.println(data1:data1);System.out.println(data2:data2);System.out.println(data3:data3);System.out.println(data4:data4);}}public static void main(String[] args) {//OutClass.innerClass innernew OutClass().new innerClass();OutClass outnew OutClass();OutClass.innerClass innerout.new innerClass();inner.innerMethod();}
} 2. 实例内部类所处的位置与外部类成员位置相同因此也受public、private等访问限定符的约束 3. 在实例内部类方法中访问同名的成员时优先访问自己的如果要访问外部类同名的成员必须外部类名 称.this.同名成员 来访问
public class OutClass {public int data11;private int data22;int data33;public static int data44;public void outMethodA(){System.out.println(data1:data1);}public static void outMethodB(){System.out.println(data4:data4);}//定义一个实例内部类class innerClass{//在实例内部类当中可以访问任意访问修饰限定符的成员//在实例内部类当中创建一个方法public void innerMethod(){// 在实例内部类中可以直接访问外部类中任意访问限定符修饰的成员data110;data220;data330;data440;outMethodA();outMethodB();System.out.println(data1:data1);System.out.println(data2:data2);System.out.println(data3:data3);System.out.println(data4:data4);// 如果外部类和实例内部类中具有相同名称成员时优先访问的是内部类自己的int data11;System.out.println(内部data1:data1);// 如果要访问外部类同名成员时候必须外部类名称.this.同名成员名字System.out.println(外部data1:OutClass.this.data1);}}public static void main(String[] args) {//OutClass.innerClass innernew OutClass().new innerClass();OutClass outnew OutClass();OutClass.innerClass innerout.new innerClass();inner.innerMethod();}
} 4. 实例内部类对象必须在先有外部类对象前提下才能创建 public static void main(String[] args) {// 要访问实例内部类中成员必须要创建实例内部类的对象// 而普通内部类定义与外部类成员定义位置相同因此创建实例内部类对象时必须借助外部类// 创建实例内部类对象//OutClass.innerClass innernew OutClass().new innerClass();// 上述语法比较怪异也可以先将外部类对象先创建出来然后再创建实例内部类对象OutClass outnew OutClass();OutClass.innerClass innerout.new innerClass();inner.innerMethod();} 5. 实例内部类的非静态方法中包含了一个指向外部类对象的引用 6. 外部类中不能直接访问实例内部类中的成员如果要访问必须先要创建内部类的对象。 4.2 静态内部类
被static修饰的内部成员类称为静态内部类。
1. 在静态内部类中只能访问外部类中的静态成员字段和方法 如果确实想访问我们该如何做
我们可以在静态方法内部新建一个外部类的对象就可以访问了~ 2. 创建静态内部类对象时不需要先创建外部类对象
public static void main(String[] args) {// 静态内部类对象创建(不需要先创建外部类的对象)OutClass.innerClass2 innernew OutClass.innerClass2();//静态内部类的成员访问innerClass2.innerMethod();}
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. 几乎不会使用
4.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.Person1b6d3586我们可以简单的认为打印了一个类似与地址的东西实际上是该类所创建对象的哈希值 如果想要默认打印对象中的属性该如何处理呢答案重写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;}Overridepublic String toString() {return [ name , gender , age ];}public static void main(String[] args) {Person person new Person(Jim,男, 18);System.out.println(person);}
}// 输出结果[Jim,男,18]当然在IDEA中也有快速重写toString方法的方式~
1右击鼠标点击生成 2弹出此窗口点击toString() (3)点击确定即可 4看一下效果~ 6、 完结散花
好了这期的分享到这里就结束了~
如果这篇博客对你有帮助的话可以用你们的小手指点一个免费的赞并收藏起来哟~
如果期待博主下期内容的话可以点点关注避免找不到我了呢~
我们下期不见不散~~
