第天面七向对象
今日内容介绍
构造方法
this语句
super语句
第1章构造方法
我们对封装已经有了基本的了解，接下来我们来看一个新的问题，依然以Person为例，由于Person中的属性都被private了，外界无法直接访问属性，必须对外提供相应的set和get方法。当创建人对象的时候，人对象一创建就要明确其姓名和年龄，那该怎么做呢？
1.1构造方法介绍
在开发中经常需要在创建对象的同时明确对象的属性值，比如员工入职公司就要明确他的姓名、年龄等属性信息。
那么，创建对象就要明确属性值，那怎么解决呢？也就是在创建对象的时候就要做的事情，当使用new关键字创建对象时，怎么给对象的属性初始化值呢？这就要学习Java另外一门小技术，构造方法。
那什么是构造方法呢？从字面上理解即为构建创造时用的方法，即就是对象创建时要执行的方法。既然是对象创建时要执行的方法，那么只要在new对象时，知道其执行的构造方法是什么，就可以在执行这个方法的时候给对象进行属性赋值。
构造方法的格式：
修饰符 构造方法名(参数列表){
}
构造方法的体现：
构造方法没有返回值类型。也不需要写返回值。因为它是为构建对象的，对象创建完，方法就执行结束。
构造方法名称必须和类型保持一致。
构造方法没有具体的返回值。
构造方法的代码体现：
class Person {
// Person的成员属性age和name
private int age;
private String name;
// Person的构造方法，拥有参数列表
Person(int a, String nm) {
// 接受到创建对象时传递进来的值，将值赋给成员属性
age = a;
name = nm;
}
}
1.2构造方法调用和内存图解
理解构造方法的格式和基本功能之后，现在就要研究构造方法是怎么执行的呢？在创建对象的时候是如何初始化的呢？
构造方法是专门用来创建对象的，也就是在new对象时要调用构造方法。现在来看看如何调用构造方法。
public class Person {
private String name;
private int age;
//Person类的构造方法
/* 1.构造方法没有返回值类型
* 2.构造方法的方法名就是类名
*/
public Person(String name,int age){//构造方法的局部变量name,age
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 class Demo02 {
public static void main(String[] args) {
Person p=new Person(“小张”,20);
System.out.println(p.getName()+" "+p.getAge());
}
}
上述代码演示了创建对象时构造方法的调用。即在创建对象时，会调用与参数列表对应的构造方法。
上述代码的图解：
1.3构造方法的细节
1.3.1默认构造方法
在没有学习构造方法之前，我们也可以通过new关键字创建对象，并调用相应的方法，同时在描述事物时也没有写构造方法。这是为什么呢？
在之前学习的过程中，描述事物时，并没有显示指定构造方法，当在编译Java文件时，编译器会自动给class文件中添加默认的构造方法。如果在描述类时，我们显示指定了构造方法，那么，当在编译Java源文件时，编译器就不会再给class文件中添加默认构造方法。
class Person {
//如果没有显示指定构造方法，编译会在编译时自动添加默认的构造方法
//Person(){} //空参数的默认构造方法
}
当在描述事物时，要不要在类中写构造方法呢？这时要根据描述事物的特点来确定，当描述的事物在创建其对象时就要明确属性的值，这时就需要在定义类的时候书写带参数的构造方法。若创建对象时不需要明确具体的数据，这时可以不用书写构造方法（不书写也有默认的构造方法）。
1.3.2构造方法的重载：
1、一个类中可以有多个构造方法，多个构造方法是以重载的形式存在的
2、构造方法是可以被private修饰的，作用：其他程序无法创建该类的对象
public class Person {
private String name;
private int age;
//默认构造方法
public Person(){
}
public Person(String name){
this.name=name;
}
//Person类的构造方法
/* 1.构造方法没有返回值类型
* 2.构造方法的方法名就是类名
*/
public Person(String name,int age){//构造方法的局部变量name,age
this.name=name;
this.age=age;
}
//成员方法,一般不会这样定义
/* public void Person(String name,int 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;
}
}
1.4构造方法和一般方法区别
到目前为止，学习两种方法，分别为构造方法和一般方法，那么他们之间有什么异同呢？
构造方法在对象创建时就执行了，而且只执行一次。
一般方法是在对象创建后，需要使用时才被对象调用，并可以被多次调用。
问题：
有了构造方法之后可以对对象的属性进行初始化，那么还需要对应的set和get方法吗？
需要相应的set和get方法，因为对象在创建之后需要修改和访问相应的属性值时，在这时只能通过set或者get方法来操作。
思考，如下代码有问题吗？
class Person {
void Person() {
}
}
class PersonDemo {
public static void main(String[] args) {
Person p = new Person();
}
}
第2章this 关 键 字 与 this语句
在之前学习方法时，我们知道方法之间是可以相互调用的，那么构造方法之间能不能相互调用呢？若可以，怎么调用呢？
2.1 this关键字解决：成员变量和局部变量同名问题
当在方法中出现了局部变量和成员变量同名的时候，那么在方法中怎么区别局部变量成员变量呢？可以在成员变量名前面加上this.来区别成员变量和局部变量
class Person {
private int age;
private String name;
public void speak() {
this.name = "小强";
this.age = 18;
System.out.println("name=" + this.name + ",age=" + this.age);
}
}
class PersonDemo {
public static void main(String[] args) {
Person p = new Person();
p.speak();
}
}
2.2this的内存解释
我们已经学习了如何把生活中的事物使用Java代码描述，接下来我们分析对象在内存中的分配情况。这里需要画图一步一步演示，严格按照画图流程讲解内存对象创建使用过程。
public class Person {
private String name;
private int age;
// 设置年龄方法
public void setAge(int age) {
//age = age;//这句话相当于 setAge上的age变量自身给自身赋值
this.age=age;//this.age访问的就是成员变量
}
// 获取年龄
public int getAge() {
return age;
}
public void eat() {
System.out.println(name+"..."+age);
}
}
public class PersonDemo {
public static void main(String[] args) {
Person p=new Person();
p.setAge(10);//setAge()中的参数a不够见名知义
//当调用setAge(int a),看到a不知道a的具体含义
System.out.println(p.getAge());
p.eat();
}
}
下图为程序中内存对象的创建使用过程。
图1-1内存对象创建使用过程
2.3this语句调用构造方法
在之前学习方法之间调用时，可以通过方法名进行调用。可是针对构造方法，无法通过构造方法名来相互调用。
构造方法之间的调用，可以通过this关键字来完成。
构造方法调用格式：
this(参数列表);//必须放在构造函数第一行
构造方法的调用
class Person {
// Person的成员属性
private int age;
private String name;
// 无参数的构造方法
Person() {
}
// 给姓名初始化的构造方法
Person(String nm) {
name = nm;
}
// 给姓名和年龄初始化的构造方法
Person(String nm, int a) {
// 由于已经存在给姓名进行初始化的构造方法 name = nm;因此只需要调用即可
// 调用其他构造方法，需要通过this关键字来调用
this(nm);
// 给年龄初始化
age = a;
}
}
2.4this语句的内存图解
了解了构造方法之间是可以相互调用，那为什么他们之间通过this就可以调用呢？
通过上面的学习，简单知道使用this可以实现构造方法之间的调用，但是为什么就会知道this调用哪一个构造方法呢？接下来需要图解完成。
public class Person {
private String name;
private int age;
//默认构造方法
public Person(){
}
//含有一个参数构造
public Person(String name){//name="令狐冲"
//this.name=name;
this(name,13);//调用其它构造方法:Person(String,int)
}
//Person类的构造方法
/* 1.构造方法没有返回值类型
* 2.构造方法的方法名就是类名
*/
public Person(String name,int age){//String name="令狐冲"
//age=13
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;
}
}
2.5this关键字与this语句案例
学习完了构造方法、this的用法之后，现在做个小小的练习。
需求：在Person类中定义功能，判断两个人是否是同龄人
class Person {
private int age;
private String name;
// 给姓名和年龄初始化的构造方法
Person(String name, int age) {
// 当需要访问成员变量是，只需要在成员变量前面加上this.即可
this.name = name;
this.age = age;
}
// 判断是否为同龄人
public boolean equalsAge(Person p) {
// 使用当前调用该equalsAge方法对象的age和传递进来p的age进行比较
// 由于无法确定具体是哪一个对象调用equalsAge方法，这里就可以使用this来代替
/*
* if(this.age == p.age) { return true; } return false;
*/
return this.age = p.age;
}
}
this语句的案例,分析一段Java中的源码,很好证明this语句的应用:
ctrl+shift+T,输入类名JDialog(JDK中的写好一个类),我们主要研究他的构造方法
public class JDialog{
public JDialog() {
this((Frame)null, false);
}
public JDialog(Frame owner) {
this(owner, false);
}
public JDialog(Frame owner, boolean modal) {
this(owner, “”, modal);
}
public JDialog(Frame owner, String title) {
this(owner, title, false);
}
public JDialog(Frame owner, String title, boolean modal) {
//其它的构造方法最终都是通过this语句最终调用这个构造方法
//真正的逻辑代码写在这个构造函数中
}
}
第3章封装
3.1 封装概述
提起封装，大家并不陌生。前面我们学习方法时，就提起过，将具体功能封装到方法中，学习对象时，也提过将方法封装在类中，其实这些都是封装。
封装，它也是面向对象思想的特征之一。面向对象共有三个特征：封装，继承，多态。接下来我们具体学习封装。
封装表现：
1、方法就是一个最基本封装体,方法封装了很多语句
public void sort(int[] arr){
//冒泡排序算法
}
2、类其实也是一个封装体,封装了属性(成员变量)和行为(成员方法)
class Car{
String brand;
String color;
int number;
public void run(){
}
}
从以上两点得出结论，封装的好处：
1、提高了代码的复用性。
例如:
//求长方形的面积的代码我们只需要在方法中写一次
//这个方法可以反复使用
getArea(3,4);
getArea(10,11);
//求长方形的面积
public static int getArea(int width,int length){
return width*length;
}
2、隐藏了实现细节，还要对外提供可以访问的方式。便于调用者的使用。这是核心之一，也可以理解为就是封装的概念。
Scanner scanner=new Scanner(System.in);
int i=scanner.nextInt()//我们在使用的时候不需要关心底层的实现细节
//对用户(使用者)是隐藏的
3、提高了安全性。
3.2 封装举例
机箱：
一台电脑，它是由CPU、主板、显卡、内存、硬盘、电源等部件组长，其实我们将这些部件组装在一起就可以使用电脑了，但是发现这些部件都散落在外面，很容造成不安全因素，于是，使用机箱壳子，把这些部件都装在里面，并在机箱壳上留下一些插口等，若不留插口，大家想想会是什么情况。
总结：机箱其实就是隐藏了办卡设备的细节，对外提供了插口以及开关等访问内部细节的方式。
3.3 私有private
了解到封装在生活的体现之后，又要回到Java中，细说封装的在Java代码中的体现，先从描述Person说起。
描述人。Person
属性：年龄。
行为：说话：说出自己的年龄。
class Person {
int age;
String name;
public void show() {
System.out.println("age=" + age + ",name" + name);
}
}
public class PersonDemo {
public static void main(String[] args) {
// 创建Person对象
Person p = new Person();
p.age = -20; // 给Person对象赋值
p.name = “人妖”;
p.show(); // 调用Person的show方法
}
}
通过上述代码发现，虽然我们用Java代码把Person描述清楚了，但有个严重的问题，就是Person中的属性的行为可以任意访问和使用。这明显不符合实际需求。
可是怎么才能不让访问呢？需要使用一个Java中的关键字也是一个修饰符 private(私有，权限修饰符)。只要将Person的属性和行为私有起来，这样就无法直接访问。
class Person {
private int age;
private String name;
public void show() {
System.out.println("age=" + age + ",name" + name);
}
}
年龄已被私有，错误的值无法赋值，可是正确的值也赋值不了，这样还是不行，那肿么办呢？按照之前所学习的封装的原理，隐藏后，还需要提供访问方式。只要对外提供可以访问的方法，让其他程序访问这些方法。同时在方法中可以对数据进行验证。
一般对成员属性的访问动作：赋值(设置 set)，取值(获取 get)，因此对私有的变量访问的方式可以提供对应的 setXxx或者getXxx的方法。
class Person {
// 私有成员变量
private int age;
private String name;
// 对外提供设置成员变量的方法
public void setAge(int a) {
// 由于是设置成员变量的值，这里可以加入数据的验证
if (a < 0 || a > 130) {
System.out.println(a + "不符合年龄的数据范围");
return;
}
age = a;
}
// 对外提供访问成员变量的方法
public void getAge() {
return age;
}
}
总结：
类中不需要对外提供的内容都私有化，包括属性和方法。
以后再描述事物，属性都私有化，并提供setXxx getXxx方法对其进行访问。
注意：私有仅仅是封装的体现形式而已。
第4章权限修饰符
在Java中提供了四种访问权限，使用不同的访问权限时，被修饰的内容会有不同的访问权限，以下表来说明不同权限的访问能力：
public protected default private
同一类中 √ √ √ √
同一包中不同类 √ √ √
不同包中的无关类 √ √
不同包中的子父类 √
归纳一下：在日常开发过程中，编写的类、方法、成员变量的访问
要想仅能在本类中访问使用private修饰；
要想本包中的类都可以访问不加修饰符即可；
要想本包中的类与其他包中的子类可以访问使用protected修饰
要想所有包中的所有类都可以访问使用public修饰。
注意：如果类用public修饰，则类名必须与文件名相同。一个文件中只能有一个public修饰的类。
第5章匿名对象
5.1匿名对象的概念
匿名对象是指创建对象时，只有创建对象的语句，却没有把对象地址值赋值给某个变量。
如：已经存在的类：
public class Person{
public void eat(){
System.out.println();
}
}
创建一个普通对象
Person p = new Person();
创建一个匿名对象
new Person();
5.2匿名对象的特点
创建匿名对象直接使用，没有变量名。
new Person().eat() //eat方法被一个没有名字的Person对象调用了。
匿名对象在没有指定其引用变量时，只能使用一次。
new Person().eat(); 创建一个匿名对象，调用eat方法
new Person().eat(); 想再次调用eat方法，重新创建了一个匿名对象
匿名对象可以作为方法接收的参数使用
/*
- 匿名对象:无名对象
- new 类名(参数)
- 匿名对象:
- 适合于仅使用这个对象一次,我们经常用来传递参数
*/
class Person {
int number;
public Person() {
}
public Person(int i) {
}
}
public class Demo01 {
public static void main(String[] args) {
//method01();
//method02();
/*Person p=new Person();
method03(p);*/
method03(new Person());
}
public static void method03(Person p){//Person p=new Person();
}
private static void method02() {
new Person().number=3;
System.out.println(new Person().number);//3
/*Person p=new Person();
p.number=3;
System.out.println(p.number);*/
}
private static void method01() {
Person p = new Person();// 对象的名字指的就是引用变量名:p
new Person();// 还是会调用指定的构造函数
new Person(3);// 还是会调用指定的构造函数
}
}
第6章static关键字
6.1static概念
当在定义类的时候，类中都会有相应的属性和方法。而属性和方法都是通过创建本类对象调用的。当在调用对象的某个方法时，这个方法没有访问到对象的特有数据时，方法创建这个对象有些多余。可是不创建对象，方法又调用不了，这时就会想，那么我们能不能不创建对象，就可以调用方法呢？
可以的，我们可以通过static关键字来实现。static它是静态修饰符，一般用来修饰类中的成员。
6.2static特点
静态成员随着类的加载而加载,随着类的销毁而销毁,静态成员存放在方法区中
正因为静态成员随着类的加载而加载,所以被static修饰的成员可以通过类名直接访问。
访问静态成员的格式：
类名.静态成员变量名
类名.静态成员方法名(参数)
对象名.静态成员变量名 ------不建议使用该方式，会出现警告
对象名.静态成员方法名(参数) ------不建议使用该方式，会出现警告
代码演示：
public class Demo01 {
String str;
static int number;
public static void method(){
}
public static void main(String[] args) {
//非静态成员的调用:通过对象调用
Demo01 d=new Demo01();
d.str=“abc”;
//静态成员的调用:可以通过类名来调用
Demo01.number=3;
System.out.println(Demo01.number);
}
}
被static修饰的成员变量属于类，不属于这个类的某个对象。（也就是说，多个对象在访问或修改static修饰的成员变量时，其中一个对象将static成员变量值进行了修改，其他对象中的static成员变量值跟着改变，即多个对象共享同一个static成员变量）
代码演示：
public class Demo03 {
static int number = 3;
String str;
public static void main(String[] args) {
Demo03 d1=new Demo03();
Demo03 d2=new Demo03();
d1.number=5;
d1.str="abc";
System.out.println(d1.str);//abc
System.out.println(d1.number);//5
System.out.println(d2.str);//null
System.out.println(d2.number);//5
}
}
6.3static细节
静态内容是优先于对象存在，只能访问静态，在静态方法中不能使用this/super关键字。静态修饰的内容存于方法区。
同一个类中，静态成员只能直接访问静态成员
非静态可以访问静态,因为静态先存在,非静态后存在,(就像:后人可以瞻仰前人,但是前人无法瞻仰后人)
public class Fu {
int number=3;
}
/*
- 静态的细节
- a.静态方法中没有this/super关键字
-
原因: -
静态方法:随着类的加载而加载,优先与对象存在 -
this:一定会指向某一个对象 -
当我通过类名调用静态方法的时候,此时没有没有任何对象 -
因此静态方法中也就没有this - b.静态成员只能直接访问静态成员,但是不能直接访问非静态
-
因为静态的成员生命周期一样,都是随着类的加载而加载 -
而非静态成员随着对象的加载而加载 -
静态成员优先于非静态成员存在 - c.非静态成员可以访问静态成员
-
静态成员比喻成 前人(古人) 李白 -
非静态成员比喻成 后人 21世纪的人
*/
public class Zi extends Fu {
String str=“abc”;
static int age=3;
public static void method() {
//突出静态方法中没有this关键字
/System.out.println(this.str);
System.out.println(super.number);/
//突出静态成员无法直接访问非静态成员
//System.out.println(str);
System.out.println(age);
}
//非静态可以直接访问静态
public void function(){
System.out.println(age);
}
}
public class Demo {
public static void main(String[] args) {
Zi.method();
}
}
6.4定义静态常量
开发中，我们想在类中定义一个静态常量，通常使用public static final修饰的变量来完成定义。此时变量名用全部大写，多个单词使用下划线连接。
/*
- public:为了保证权限足够大
- static:为了能够通过类名.静态成员访问
- final:一经初始化不可改变
*/
public class Constants {
public static final double PI=3.1415926;
}
public class Yuan {
int r;
public double getArea(){
return Constants.PIrr;
}
}
/*
- 对于之前写的圆周率的保留位数记不清了
- 我们之前使用的圆周率值是3.1415
- 现在使用的圆周率是3.1,导致值不精确
/
public class YuanZhu {
int r;
int h;
public double getTiJi(){
return Constants.PIrrh;
}
}
注意：
接口中的每个成员变量都默认使用public static final修饰。
所有接口中的成员变量已是静态常量，由于接口没有构造方法，所以必须显示赋值。可以直接用接口名访问。
interface Inter {
public static final int COUNT = 100;
}
访问接口中的静态变量
Inter.COUNT
第7章代码块
7.1局部代码块
局部代码块是定义在方法或语句中
特点：
以”{}”划定的代码区域，此时只需要关注作用域的不同即可
方法和类都是以代码块的方式划定边界的
/*
- 代码块:
- 局部代码块:{}定义在局部位置
- 构造代码块
- **静态代码块
*/
public class Demo01 {
public static void main(String[] args) {
{
int x=3;
System.out.println(x);
}
//System.out.println(x);//超出x的作用域
}
}
7.2构造代码块
构造代码块是定义在类中成员位置的代码块
特点：
优先于构造方法执行，构造代码块用于执行所有对象均需要的初始化动作
每创建一个对象均会执行一次构造代码块。
/*
*构造代码块
- 格式:定义在类中方法外,{}
- 特点:
-
当创建对象的时候,构造代码块会优先于构造函数执行,而且每创建一次对象,构造代码块就执行一次
*/
public class Demo02 {
//构造代码块
{
System.out.println(“构造代码块执行了”);
}
public Demo02(){
System.out.println("构造函数执行了");
}
public static void main(String[] args) {
new Demo02();//匿名对象
new Demo02();
}
}
7.3静态代码块
静态代码块是定义在成员位置，使用static修饰的代码块。
特点：
它优先于主方法执行、优先于构造代码块执行，当以任意形式第一次使用到该类时执行。
该类不管创建多少对象，静态代码块只执行一次。
可用于给静态变量赋值，用来给类进行初始化。
/*
- 静态代码块
- 定义在类中方法外 static{}
- 特点:
- 静态代码块随着类的加载而执行,并且只执行一次
- 静态代码块中只能直接访问静态成员
*/
public class Demo03 {
static int i;
// int j;
static {
i=3;
System.out.println(“静态代码块被执行”);
}
public Demo03() {
System.out.println("构造方法被执行");
}
public static void method(){
}
public static void main(String[] args) {
/* new Demo03();
new Demo03();*/
Demo03.method();
}
}
第8章包的声明与访问
8.1包的概念
java的包，其实就是我们电脑系统中的文件夹，包里存放的是类文件。
当类文件很多的时候，通常我们会采用多个包进行存放管理他们，这种方式称为分包管理。
在项目中，我们将相同功能的类放到一个包中，方便管理。并且日常项目的分工也是以包作为边界。
类中声明的包必须与实际class文件所在的文件夹情况相一致，即类声明在a包下，则生成的.class文件必须在a文件夹下，否则，程序运行时会找不到类。
作用:为了便于后期管理,为了分类管理
8.2包的定义格式
通常使用公司网址反写，可以有多层包，包名采用全部小写字母，多层包之间用”.”连接
包的声明,当编译java文件后的类文件会放在声明的包中
类中包的声明格式：
package 包名.包名.包名…;
如：武汉宏鹏 www.whhp.com 域名反写:com.whhp
注意：声明包的语句，必须写在程序有效代码的第一行（注释不算）
代码演示：
package com.whhp; //包的声明，必须在有效代码的第一行
import java.util.Scanner;
import java.util.Random;
public class Demo {}
8.3包的访问
两个类在不同包下，必须使用含有包名的类全名（包名.类名）来访问。
包名.包名….类名
如： java.util.Scanner
java.util.Random
带有包的类，创建对象格式：包名.类名 变量名 = new包名.类名();
java.util.Scanner scan=new java.util.Scanner(System.in);
当我们要使用一个类时，这个类与当前程序在同一个包中（即同一个文件夹中），或者这个类是java.lang包中的类时通常可以省略掉包名，直接使用该类。
8.4import导包
我们每次使用类时，都需要写很长的包名。很麻烦，我们可以通过import导包的方式来简化。
可以通过导包的方式使用该类，可以避免使用全类名编写（即，包类.类名）。
导包的格式：
import 包名.类名;
当程序导入指定的包后，使用类时，就可以简化了。演示如下
//导入包前的方式
//创建对象
java.util.Scanner sc1 = new java.util.Scanner(System.in);
java.util.Scanner sc2 = new java.util.Scanner(System.in);
//导入包后的方式
import java.util.Scanner;
//创建对象
Scanner sc1 = new Scanner(System.in);
Scanner sc2 = new Scanner(System.in);
import导包代码书写的位置：在声明包package后，定义所有类class前，使用导包import包名.包名.类名;
需要免费的java基础视频和java企业级开发视频以及项目实战（包含SSM框架详细讲解、activiti流程引擎、springboot、springcloud视频讲解和项目实战课程）可以添加qq：1743337375
扫一扫
1787
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
