【JAVA】类和对象（part2）

最新推荐文章于 2022-08-15 21:17:28 发布

'Dream是普通小孩耶

最新推荐文章于 2022-08-15 21:17:28 发布

阅读量205

点赞数

分类专栏： Note-JavaSE 文章标签： java 开发语言类和对象

本文链接：https://blog.csdn.net/weixin_54150521/article/details/125775931

版权

Note-JavaSE 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

类和对象回顾

一定要逼自己一把！！你一定可以！
回顾复习：类和对象
1.面向对象面向过程
2.对象–>先定义一个类【类型】
语法：class 类名 {
属性/成员方法：定义在类内部，方法的外部行为/成员方法}
3.通过类可以实例化一个对象。一个类可以通过new关键字实例化多个对象
4.通过对象的引用可以访问对象的成员方法和成员变量。
eg.Dog dog = new Dog();
dog.name; dog.eat();
5.this:代表当前对象的引用。
this.成员方法 this.成员变量
this();【调用类的构造方法，只能放在第一行】
6.构造方法：方法名与类名一致，没有返回值。
当new Dog（）；实例化对象的时候就会被调用，对应的构造方法就会被调用。
构造方法有多个，可以重载。
构造方法没有写的时候，编译器会提供一个不带参数的构造方法；但是你一旦提供了任何一个构造方法，编译器就不会为你提供构造方法了。
7.在构造方法中，可以对成员变量进行初始化：
就地初始化、默认初始化【0、null、false】、构造方法初始化、使用get、set方法进行初始化数据
8.封装：实现对细节的隐藏，同时提供了公开的方法对封装的方法或属性进行交互，提高了安全性。
用private进行修饰，只能在当前类中被访问，类外不可以进行访问。

冲冲冲吖！

六、封装

1. 封装的概念

面向对象有三个比较重要的思想：封装、继承和多态。（OOP语言三大特征）
（注：有时面向对象四个特征：抽象、封装、继承、多态）
而类和对象阶段，主要研究的就是封装特性。何为封装呢？简单来说就是套壳屏蔽细节。
封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。
封装–对类的细节进行隐藏
不想让类外看到我具体的实现手段，所以用技术手段将细节进行封装。提供公开的接口让你来交互即可
对于使用该类的人来说，并不关心类的实现细节，只关心该类提供的接口的交互就可

2. 访问限定符

访问限定修饰符
注：

默认权限：在同一个包中进行访问
private：只能在当前类中访问，在类外不可以访问
可以利用公开接口（另写一个方法进行private的属性修饰）
利用右键–Generate可以做到get set的直接输入–一般建议每个属性分开–耦合度较低
好的代码：
易读、效率高、耦合度低、注释

3. 封装扩展之包

1. 包的概念

为了更好的管理类，把多个类收集在一起成为一组，称为软件包。有点类似于目录。

2. 导入包中的类

使用 import语句导入包
更建议显式的指定要导入的类名，否则还是容易出现冲突的情况。
可以使用import static导入包中静态的方法和字段（一般不用）

3. 自定义包

基本规则

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

注意：包名建议小写！！
IDEA建包基本步骤
idea如何建包：src选中–右键–package–包的名称一般是公司域名的倒置
查看：右键–open–explorer
齿轮–Tree–Comp–就可以分行显示
在此之下建立的java源文件会带有package，表示在哪个包之下
import–导包

4. 访问限定修饰符

访问修饰限定符：
public：哪里都可以访问
private：当前类中访问
默认只能在当前所在的包里进行访问
一般字段private修饰方法public修饰
常见的包

java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。
java.lang.reflect:java 反射编程包;
java.net:进行网络编程开发包。
java.sql:进行数据库开发的支持包。
java.util:是java提供的工具程序包。(集合类等) 非常重要
java.io:I/O编程开发包。

.* --用到啥导入啥

七、static成员方法

1.static修饰成员变量及成员方法

静态成员变量存到方法区！！–只有一份
静态成员变量【类变量】：不属于对象，所有对象共享
所以调用静态成员变量一般通过类名.静态成员变量访问
（引用变量.静态成员变量也可以，但是不推荐）
成员变量：
普通成员变量：通过对象引用来调用
静态成员变量：通过类引用来调用
static修饰方法–静态方法：
同样通过类名进行调用，不需要对象
静态方法不依赖于对象，但是普通成员变量依赖于对象，所以不可以在静态方法中调用普通成员方法
可以在普通方法中调用（赋值）类变量，因为类变量并不依赖于对象
静态方法中，不能直接访问非静态的数据，若是想访问就
1）在静态方法中实例化对象（new），再进行对象.成员变量的调用
2）静态方法中传参（类名对象），再进行对象.成员变量的调用
（总结一下就是：通过对象的引用来访问非静态成员）
final修饰的成员变量是常量，不可以进行修改，必修初始化
静态成员变量特性：
1）不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中
2）既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问
3）类变量存储在方法区当中
4）生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)
java中，被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。
静态方法的特性：
1）不属于某个具体的对象，是类方法
2）可以通过对象调用，也可以通过类名.静态方法名(…)方式调用，更推荐使用后者
3） 不能直接在静态方法中访问任何非静态成员变量
4） 静态方法中不能直接调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用
静态方法无法重写，不能用来实现多态。

2. static成员变量初始化

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

就地初始化：在定义时直接进行赋值
静态代码块初始化

八、代码块

1. 代码块概念以及分类

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

普通代码块：又称本地代码块–定义在方法中{}
构造块：又称实例代码块–定义在类的内部，方法的外部–可以初始化实例的数据成员
静态块：类内部方法外部，但是有static修饰–如：static{ //一般用于初始化静态成员…}
同步代码块：与多线程部分有关
（其中：构造块和静态块是重点）

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. 构造代码块

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

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 = "Jim"; 
  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: Jim age: 12 sex: man

4. 静态代码块

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

public class Student{
 private String name;
 private String gender;
 private int age;
 private double score;
 private static String classRoom; 
 //实例代码块 
  { 
  this.name = "JIm"; 
  this.age = 12;
  this.gender = "man";
  System.out.println("I am instance init()!"); 
  }
  // 静态代码块 
  static {
  classRoom = "com105"; 
  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(); 
} 
}

5. 注意事项

注意：
当加了代码块后，先执行静态代码块、再执行实例代码块，最后执行实例方法
（静态的是最先被加载的）
注意事项

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

小结：（执行顺序）
1.先执行静态代码块【加载了类就会被执行】
2.如果有多个静态的，那么看定义顺序（会存在覆盖）
3.如果没有实例化对象，那么只会执行静态的
（注：静态的只会执行一次）
4.实例的数据【有多个实例对象，要看定义的顺序】
5.构造方法的执行
（即：静态块、实例块、构造方法）

九、内部类

在 Java 中，可以将一个类定义在另一个类或者一个方法的内部，前者称为内部类，后者称为外部类。内部类也是封装的一种体现。
【注意事项】
1）定义在class 类名{}花括号外部的，即使是在一个文件里，都不能称为内部类
2）内部类和外部类共用同一个java源文件，但是经过编译之后，内部类会形成单独的字节码文件
内部类：
1.实例内部类
2.静态内部类
3.本地内部类–了解即可
4.匿名内部类–学完接口才知道
以后和别人说内部类的时候带上前缀

1. 内部类的分类

public class OutClass { 
// 成员位置定义：未被static修饰 --->实例内部类
 public class InnerClass1{ 

  }

// 成员位置定义：被static修饰 ---> 静态内部类 
 static class InnerClass2{ 

 }
 
 public void method(){ 
 // 方法中也可以定义内部类 ---> 局部内部类：几乎不用
  class InnerClass5{ 

  } 
 } 
}

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

成员内部类(普通内部类：未static修饰的成员内部类）
静态内部类：（被static修饰的成员内部类)
局部内部类(不谈修饰符)
匿名内部类
注意：内部类其实日常开发中使用并不是非常多，大家在看一些库中的代码时候可能会遇到的比较多，日常开发中使用最多的是匿名内部类。

2. 内部类

1. 实例内部类

实例内部类中，不能定义静态成员变量？
如果定义，那么这个静态成员变量是被final修饰的
实例内部类中，不能定义静态成员方法？
真的不能定义！
如何实例化实例内部类？
–外部类名.内部类名变量 = 外部引用变量.new 内部类名
（注意：内部类可以调用外部类的成员变量（静态、普通）
如何在内部类中访问实例内部类中和外部类同名的成员变量
内部类：（this.）成员变量
外部类：外部类名.this.成员变量
（实例内部类中包含外部类的this）
如果是同名的静态的，通过外部类类名就可以拿到
未实名实例内部类中不可以定义静态方法

2. 静态内部类

静态内部类：有static修饰的内部类
静态内部类可以有自己的构造方法与普通方法

静态内部类不依赖于对象，所以在其他类中获取内部类：(如何拿到静
态内部类对象）
OutClass.InnerClass innerClass = OutClass.new InnerClass();
不能在静态内部类中直接访问外部类非静态的数据成员
若要访问：1.外部类new一个对象
2.内部类构造方法传参（先在内部类中Public OutClass outClass;
然后OutClass outClass作为参数传入到构造方法中，再this.outClass =
outClass; 即可在其他方法中访问 outClass.变量;
(注：外部类不能是静态的，内部类ok）
注意事项
1）在静态内部类中只能访问外部类中的静态成员
2）创建静态内部类对象时，不需要先创建外部类对象、

3. 局部内部类

局部内部类：（很少使用）

定义在方法内，不能用public、static修饰等访问修饰符限定
只能在当前方法中使用

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

4. 匿名内部类

接口部分再进行详细记录

匿名对象只能使用一次：
匿名对象的创建：
如：有类 class Person{…}；
则匿名对象：new Person（）；
匿名内部类：
new Person（）{
//匿名内部类：多线程、接口使用
如有方法test（）{
}
}.test(); //直接这样子调用就行

十、对象的打印

对象的打印：sout（对象）
如：Person person = new Person();
sout(person);
当自己重新实现了toString方法（返回类型String）之后，编译器就会调用我
自己实现的这个toString方法
@Override //注解：注释+解释【代表这个方法是重写父类的】
如果输出对象的引用，想要输出的是字符串类型：则右键–Generator–toString
内部类的内存在堆上开辟（相当于一个对象，对象在内存上开辟空间）
静态内部类同样-
如果想要默认打印对象中的属性该如何处理呢？答案：重写toString方法即可。

THINK

回顾：
1.访问权限：（注意–默认：包访问权限）
2.static修饰变量-类变量：只有一份，在方法区，访问方式：
类名+. 其不能定义在普通方法中
3.类方法：类名+.
1）不包含this
2）静态方法中，不能直接访问非静态的成员变量和成员方法。
非要访问，通过对象的引用
4.构造代码块（实例代码块）
执行顺序：静态代码块（只执行一次）、实例代码块、构造方法
5.普通代码块（本地代码块):定义在方法中的
6.内部类：实例、静态、匿名、局部–提及内部类，要带前缀

Work

作业：–笔记
1.当前引用不指向任何对象–理论上会报异常，但是static修饰-类方法，不依赖于对象
2.局部变量在使用时需要进行初始化
3.static修饰的是类变量，而在方法中定义的是局部变量，不能以static修饰
（类变量是程序加载时调用）
（注：引用类型可以初始化为null）
4.static修饰的类变量如果未初始化则默认初始化
5.private权限：只能在当前类中使用
6.类访问控制关键字：3个
7.画图一下
8.在构造方法中调用重载构造方法–this（参数）；
9.成员变量未初始化则默认初始化
10.先静态块–与顺序有关
11.public
12.A.–double->float
B.this.static修饰的变量–no
C.this.成员变量–yes
D.