总结对象知识点
- 1.必要的基础知识
-
- 1.1"了解一切都是对象"
- 1.2.基本类型和引用类型
- 1.使用匿名对象
- 1.4方法重载loading...
- 1.5方法重写
-
- 1.5.1 方法重载与方法重写的区别：
- 1.形参可变数
- 1.7递归地使用
- 2.提高基础知识
-
- 2.1面向对象的特征
-
- 2.1.包装和隐藏面向对象的特征之一
-
- 2.1.1.知识扩展四种权限修饰符
- 2.1.二是继承面向对象的特征
- 2.1.面向对象的三个多态特征
- 2.2类的结构
-
- 2.2.一类结构属性之一
- 2.2.二类结构方法
- 2.2.三种结构的结构
- 2.2.代码块4类结构
- 2.2.内部类(理解)是五类结构之五
- 2.使用3个关键字
-
- 2.3.1this关键字
- 2.3.2package关键字
- 2.3.3import关键字
- 2.3.4super关键字
- 2.3.5instanceof关键字
- 2.3.6static关键字
- 2.3.7***abstract关键字
- 2.3.8***Interface关键字
- 2.总结零散的知识点
-
- 2.4.1equals()使用方法
-
- 2.4.1.1"=="和equals之间的区别
- 2.4.2toString()使用方法
- 2.4.3 单例模式
1.必要的基础知识
1.1"了解一切都是对象"
1.在Java在语言领域，我们都会 具体的结构功能是通过类的实例化来调用的。
2.涉及到Java语言与前端Html、当端数据库交互时，前后端结构在Java在层次交互中，都体现为类、对象。
1.2.基本类型和引用类型
概述： 1.基本类型:它的值是一个数字，一个字符或一个布尔值。 变量保存在赋值中---- 2.参考类型：它是一种对象类型。它的值是指向内存空间的参考，即地址。变量表示的值或一组值保存在指向内存中 引用类型的变量只能存储两种值：null或地址值(含变量类型) 变量地址保存在赋值时---- 3.数组直接赋值法： 样例：int[] arr = new int[{12，456，87，-45，56，453，452，651}； 4.值传递机制：
使用样例：
4.1如果参数是基本数据类型，那么实参赋予形参的是实参真实存储的数据值
基本数据数据类型 ValueTransferTest.java
public class ValueTransferTest {
public static void main(String[] args) {
int m = 10; int n = 20; System.out.println("交换数据前："); System.out.println("m = :" m ",n = :" n); System.out
.
println
(
"交换数据后："
)
;
ValueTransferTest test
=
new
ValueTransferTest
(
)
; test
.
swap
(m
,n
)
;
System
.out
.
println
(
"m = :"
+ m
+
",n = :"
+ n
)
;
//10，20
}
public
void
swap
(
int m
,
int n
)
{
int temp
= m
; m
= n
; n
= temp
;
//20，10
}
}
4.2 如果参数是引用数据类型,此时实参赋给形参的是—实参存储数据的地址值(含变量类型的地址值)
ValueTransferTest1.java
public class ValueTransferTest1 {
public static void main(String[] args) {
Data data = new Data();
data.m = 10;
data.n = 20;
System.out.println("交换数据前:");
System.out.println("m = "+data.m+",n = :"+data.n);
ValueTransferTest1 test1 = new ValueTransferTest1();
test1.swap(data);
System.out.println("交换数据后:");
System.out.println("m = "+data.m+",n = :"+data.n);
}
public void swap(Data data){
int temp = data.m;
data.m = data.n;
data.n = temp;
}
}
class Data{
int m;
int n;
}
2.4.1数组使用样例：
//数组排序
public void sort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - i - 1; j++) {
/*if (arr[j] > arr[j + 1]) { int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; }*/
swap(arr,j,j+1);
}
}
}
//数组中两个数值的交换
public void swap(int[] arr,int i,int j){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
1.3匿名对象的使用
InstanceTest.java 概述：
🌴1.理解：在创建对象的时候，没有给它名字，直接调用例如：new Phone().sendEmail();
🌴 2.匿名对象只能使用一次
使用样例：
public class InstanceTest {
public static void main(String[] args) {
//赋予名字对象的使用
Phone p = new Phone();
p.price = 20.0;
p.shoePrice();
p.sendEmail();
p.playGame();
//只是创建了匿名对象
new Phone().price=1999;
new Phone().shoePrice();//0.0
//匿名对象的使用
Phonemall mall = new Phonemall();
mall.show(new Phone());//在这种情况下，匿名对象可以多次使用
}
}
//mall:商场
class Phonemall{
public void show(Phone phone){
phone.sendEmail();
phone.playGame();
}
}
class Phone{
//成员变量
double price;//手机价格
//成员方法
public void sendEmail(){
System.out.println("发送邮件");
}
public void playGame(){
System.out.println("玩游戏");
}
public void shoePrice(){
System.out.println("手机的价格是："+price);
}
}
1.4方法重载loading…
OverLoadTest.java 概述
1.在同一个类中，允许存在一个以上同名的方法，只要他们的参数个数或者参数类型不同即可。
使用样例
2.举例 实现数组反转的重载：reverse(int[] arr) / reverse(double[] arr) 3. “两同一不同” 两同：同一个类中，相同方法名 不同：参数列表，参数个数不同，参数类型
4.与方法的权限修饰符，返回值类型，形参变量，方法体没有关系； 5.再通过对象调用方法时，如何确定使用的方法： 方法名------>参数列表
/* * 1.方法重载 * 2.方法重载的要点：----------同一个类，同一个名，形参列表不同---------- * */
public class OverLoadTest {
public void getSum(int i, int j) {
System.out.println(i + j);
}
public void getSum(double i, double j) {
System.out.println(i + j);
}
public void getSum(String s, int j) {
System.out.println(s + j);
}
public void getSum(int j, String s) {
System.out.println(s + j);
}
}
1.5方法重写
1.概念：
1.1重写：子类继承父类以后，可以对父类中同名同参数的方法，进行重写覆盖 1.2重写的实际意义在于：继承父类以后发现父类的方法不是自己想要执行的，所以子类就重新安排方法的内容
2.总结性内容：
2.1应用：重写以后，当创建子类对象以后，通过子类对象调用父类同名的方法以后，实际执行的是子类重写父类的方法
2.2重写的规定： 方法的声明： 权限修饰符 返回值类型 方法名(形参列表)throws 异常的类型{ //方法体 }
在实际的使用过程中，只需要将父类的权限修饰符 返回值类型 方法名(形参列表)这一部分直接粘贴过来就可以，没有那么多的规矩，下面的知识点只是帮助理解的内容：
约定的俗称：子类中的叫重写的方法，父类中的叫被重写的方法 1.子类的重写方法和父类的被重写方法的方法名和形参列表要相同 2.子类的权限修饰符不能小于父类的权限修饰符类型：private–>default(缺省)–>protected–>public –>特殊情况：父类的权限修饰符类型是private时，子类不能够重写，子类可以自己写一样的但是不认为是重写 3.：返回值类型： 3.1父类被重写方法的返回值类型是A类型，则子类重写的方法返回值类型可以是A类或者A的子类(引用数据类型) 3.2父类被重写方法的返回值类型是基本数据类型，子类重写的方法返回值类型也必须是基本数据类型 基本数据类型形如：byte、short、int、long、float、double、char、boolean等 引用数据类型：是一个对象类型，它的值是指向内存空间的引用，就是地址 3.3父类被重写方法的返回值类型是void类型，则子类重写的方法返回值也必须是void类型 4.子类和父类的同名同参数的方法要么都声明为非static的，要么都声明为static(都声明为static是重写了)
使用样例： Student类重写了Person类中的方法 Person类：
public class Person {
//属性
String name;
int age;
//构造器
public Person(){
}
public Person(String name,int age){
this.name = name;
this.age = age;
}
//方法
public void eat(){
System.out.println("吃饭");
}
public void walk(int distance){
System.out.println("走了"+distance+"公里");
}
}
学生类：
public class Student extends Person{
String major;
public Student(){
}
public Student(String major){
this.major = major;
}
public void Study(){
System.out.println("学习的专业是："+major);
}
public void eat(){
System.out.println("学生应该吃点有营养的食物");
}
@Override
public void walk(int distance) {
System.out.println("方法的重写");
}
}
1.5.1 方法重载与方法重写的区别：
二者的定义角度看 方法重载： 两同一不同“同一个类，同样的方法名，只是形参列表不同，根据不同的形参列表判断是哪一个方法” 方法重写： 在继承的基础之上，子类重写父类的方法，在创建子类对象调用时会调用子类重写父类的方法 从编译和运行的角度看 重载， 是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不同的参数表，对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。*。Java的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法。所以：对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定”； 对于多态，*******只有等到方法调用的那一刻，解释运行器才会确定所要调用的具体方法，这称为“晚绑定”或“动态绑定”。 引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚绑定，它就不是多态。”
1.6可变个数的形参
概述
可变个数的使用格式:数据类型…变量名 传入的参数格式可以是1，2，3…
使用样例
public void show(String...strs){
System.out.println(strs);
}
2.可变个数的形参方法可以与本类方法名相同，参数不同的形参方法实现共存 show(String s) show(String…s) 3.可变个数的形参方法需要声明在末尾 使用样例： public void show(int i,String…strs){ System.out.println(strs); }
1.7递归地使用
概述：
1.递归方法： 一个方法体内调用自身；
2.递归方法包含了一种隐含式的循环控制，它会重复执行其中的一段代码，但是它不需要使用循环控制； 3.递归一定要向一直方向递归
使用样例：
//给出递归式f(0) = 1; f(1) = 4;
//f(n+2) = 2*f(n+1)+f(n);
public int f(int n) {
if (n == 0) {
return 1;
} else if (n == 1) {
return 4;
} else {
return 2 * f(n - 1) + f(n - 2);
}
}
2.进阶基础知识
2.1面向对象的特征
2.1.1面向对象的特征之一封装和隐藏
理解性内容 ：
🌴1.高内聚：类的内部操作细节自己完成，不允许外部干涉； 低耦合：进对外暴露少量的方法用于使用隐藏对象内部的复杂性，之对外公开简单的接口。便于外界的调用，从而提高系统的可扩展性、可维护性。 🌴通俗的说，---------把该隐藏的隐藏起来，该暴露的暴露出来，这就是封装性的设计思想。
概述：
🌴 2.****封装：把属性封装起来，把该属性的权限设置为私有变量，对外部不可见（不可以直接调用，必须使用方法），但是可以使用方法来使用该属性【存在但是用不了】需要对属性加上额外的限制条件
🌴 官方一点的介绍： 当我们创建一个类的对象的时候，我们可以通过“对象.属性”的方式，对对象的属性进行赋值， 这里赋值操作会受到属性的数据类型和存储范围的制约。----------除此之外，没有其他的限制条件 🌴 【 但是在实际的问题中，我们往往需要给属性赋值加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加，同时需要避免用户使用“对象.属性”的方式进行赋值，此时就体现了 封装性；
🌴 3.封装性的体现：我们将类的对象属性私有化（private）,并且提供公共的方法进行获取(getXXX)和设置(setXXX)[仅仅是这一点体现了封装性，并不代表这就是封装性] 另一个使用：不对外暴露的方法，类的内部的方法使用
🌴 4.封装性的体现，需要权限修饰符来配合
2.1.1.1知识拓展之四种权限修饰符
1 🌴Java规定的四种权限（从小到大排列）：private、缺省(default)、protected、public
| 修饰符 | 类内部 | 同一个包中 | 不同包的子类中 | 同一个工程 |
|---|---|---|---|---|
| private | Yes | |||
| default(缺省) | Yes | Yes | ||
| protected | Yes | Yes | Yes | |
| public | Yes | Yes | Yes | Yes |
🌴 2四种权限可以修饰类的内部结构：属性、方法、构造器、内部类 在修饰类的时候，只能使用缺省（默认情况下的）、public //如果类是缺省，在不同的包中，即使属性是public也不能使用； 🌴 3.对象对于不同权限属性和方法的调用规则 3.1对于同一个包同一个类，所有的属性和方法都可以调用 3.2对于同一个包的普通类，可以使用除private修饰的方法和属性其他的都可以调用 3.3对于不同包的子类，可以重写和使用protected和public修饰的属性及方法 3.4对于不同包的普通类（和其他的的类没有任何的关系），只能使用public修饰的属性和方法
🌴4.总结：Java提供了四种权限修饰符类修饰类及类的内部结构，体现类及类的内部结构在被调用时可见性的大小；
2.1.2面向对象的特征之二继承
🌴1.概念: 官方概念： 继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。
个人理解： 继承就是说一个类2可以继承另一个类1，类1里面—所有—的属性，方法类2都可以直接使用，不用再另外声明。 注解：使用private修饰的成员变量实际上继承到了，但是由于封装性的影响，只能使用set和get来进行设置和获取 🌴2.继承的好处： 2.1:减少了代码的冗余度，提高了代码的复用性；子类可以直接使用父类的成员变量，方法 2.2:便于功能的扩展；如果有多个子类都拥有某一个方法可以在父类中声明，所有用到的子类直接调用即可 2.3:为之后多态性的使用提供了前提 🌴3.继承的格式： class A extends B{} A：子类、派生类、subclass; B：父类、超类、基类、superclass; 3.1继承的体现：一旦子类A继承父类B之后,子类A就获取了父类B中声明的所有属性和方法 3.2子类继承父类以后，子类可以定义自己的属性和方法，实现功能的拓展； 3.3子类和父类的关系：子类的功能更丰富一些
4.1一个类可以被多个子类继承； 4.2Java中类的继承性：一个类只能有一个父类 4.3子父类是相对的概念； 4.4子类直接继承的父类，称为：直接父类。间接继承的父类成为：间接父类 4.5子类继承父类以后，就获取了直接父类以及间接父类的所有属性和方法
使用样例： Person类：
public class Person {
//属性
String name;
int age;
//构造器
public Person(){
}
public Person(String name,int age){
this.name = name;
this.age = age;
}
//方法
public void eat(){
System.out.println("吃饭");
}
public void walk(int distance){
System.out.println("走了"+distance+"公里");
}
}
student类：
public class Student extends Person{
String major;
public Student(){
}
public Student(String major){
this.major = major;
}
public void Study(){
System.out.println("学习的专业是："+major);
}
public void eat(){
System.out.println("学生应该吃点有营养的食物");
}
@Override
public void walk(int distance) {
System.out.println("方法的重写");
}
}
2.1.3面向对象的特征之三多态
秒懂多态：
1.理解多态性： 可以理解为一个事务的多种形态 2.多态的使用规则： 在创建对象的时候使用如下规则 —> 父类 对象名 = new 父类的人一个子类 样例：Person m1 = new Man(); 3.何为多态性：父类的引用指向子类的对象(或者子类的对象赋给父类的引用) 4.多态的使用，-----虚拟方法的调用----- 有了对象的多态性以后，我们在编译期间，只能调用父类中声明的方法，但是在运行期， 我们实际上执行的是子类重写父类的方法 总结：编译看左边，执行看右边；父类的方法称为虚拟方法
5.1有继承关系 5.2子类重写父类的方法 (子类通常都会重写方法，要不然就没有必要[new 子类],使用多态) 备注：***只能调用父类拥有的方法 ***，但是执行的时候使用的是右边重写的 6.对象的多态性：只适用于方法，不适用于属性(属性在子类和父类中都有，会调用父类的属性值) 7.多态只能调用父类的方法，不能调用子类的方法
使用样例：public class AnimalTest { public static void main(String[] args) { AnimalTest test = new AnimalTest(); //多态的使用 test.func(new Dog()); test.func((new Cat())); } public void func(Animal animal){ //实际的使用过过程中Animal animal = new 对象类(); animal.eat(); animal.shout()