APP逆向 day8 JAVA基础3

一.前言

昨天我们讲了点java基础2.0，发现是又臭又长，今天就是java基础的最后一章，也就是最难的，面向对象。上一末尾也是提到了面向对象，但是面向对象是最重要的，怎么可能只有这么短呢？所以今天和大家讲讲面向对象中重要的东西，顺便再讲讲封装继承多态以及包。

二.类与对象

1.类与对象解释
（1）类：
类是实体对象的概念模型，是笼统的、不具体的，比如人类，动物类，鸟类
类是描述了一组有相同特性（属性）和相同行为（方法）的一组对象的集合
（2）对象：
对象又称为【实体】，是类具体化的表现，如人类中有：厨师，学生，老师
每个人对象都具有：姓名、年龄和体重这些属性，但是每个对象的姓名年龄又不相同
每个对象都具有：说话，走路的方法


2.java是完全的面向对象，没有面向过程
   所有代码都在类中定义---》java程序有入口--》类下main方法

2.1 类定义的规范

Java中类的定义规范
// []内可以省略，|表示或单两个关键字不能同时出现
[public] [abstract|final] class 类名class_name [extends 继承的类名] [implements 实现的接口名] {
// 定义成员属性
   属性类型1 属性名1; // String name;
  属性类型2 属性名2; // int age;
// 定义静态属性（类属性）
   static 属性类型属性名;

// 定义成员方法(对象方法，对象来调用的方法)
public int add(int a,int b){
return a+b;
}
   // 定义静态方法（类方法，类来调用）
public static void speak(){
System.out.println("说话");
}

}
// 解释
public ：表示公有的意思。如果使用 public 修饰，则可以被其他类和程序访问。每个 Java 程序的主类都必须是 public 类，作为公共工具供其他类和程序使用的类应定义为 public 类

abstract ：类被 abstract 修饰，则该类为抽象类，抽象类不能被实例化，但抽象类中可以有抽象方法（使用 abstract 修饰的方法）和具体方法（没有使用 abstract 修饰的方法）。继承该抽象类的所有子类都必须实现该抽象类中的所有抽象方法（除非子类也是抽象类）

final ：如果类被 final 修饰，则不允许被继承
class ：声明类的关键字
class_name ：类的名称
extends ：表示继承其他类

implements ：表示实现某些接口

这里后面都会讲到，我就不给出示例代码了，要不然比上一期还又臭又长。

2.2 java类的属性

语法
[public|protected|private] [static][final] <变量类型> <变量名>
// 解释
public protected private ：用于表示成员变量的访问权限一会详细讲
static ：表示该成员变量为类变量，也称为静态变量
final ：表示将该成员变量声明为常量，其值无法更改
变量类型：表示变量的类型
变量名：表示变量名称

[public|protected|private] [static][final] 这些是既可以修饰类又可以修饰属性吗
public ,final abstract 修饰类
public,protected,private static final 修饰属性

示例代码

public class main {
    // java类中的属性
}

class Person{
    public String name; 
    protected int age;
    private  String hobby;

    public static String school;
    protected static int age1;

    public static final String xx="往日情怀酿作酒"; // 常量
    static final String yy="往日情怀酿作酒";  // 类来用的常量
    final String zz="往日情怀酿作酒"; //对象来用的常量
}

2.3 java类中的方法

这里类的方法就分为两种，一种是给类使用的，一种是给对象来使用的

1.语法
[public|private|protected] [abstract] [static] <void|return_type><方法名>([参数]) {
// 方法体
}

2.解释
public private protected ：表示成员方法的访问权限
static ：表示限定该成员方法为静态方法，一些公共方法，咱们可以定义为静态的
final ：表示限定该成员方法不能被重写或重载
abstract ：表示限定该成员方法为抽象方法。抽象方法不提供具体的实现，并且所属类型必须为抽象类

示例代码

public class main {

    public static void main(String[] args) {
        //对象来调用
        Person p1=new Person();
        p1.getname();
        System.out.println(p1.add(1,3));

        //类直接调用
        Person.stcgetname();
        System.out.println(Person.stcadd(1,3));
    }


}

class Person{
    public String name;

    //无返回值的 对象来调用
    public void getname(){
        System.out.println(this.name);
    }

    //无返回值的 类直接调用
    public static void  stcgetname(){
        System.out.println("往日情怀酿作酒");
    }

    //有返回值的 对象来调用
    public  int add(int a,int b){
        return a+b;
    }

    //有返回值的 类来调用
    public static int stcadd(int a,int b){
        return a+b;
    }


}

我们可以发现 static（静态方法就是类来直接调用的）

2.4 构造方法

构造方法很特殊，构造方法与类名相同，不需要void，可以有多个表示不同的构造方法，他们之间的区别就是通过不同的参数来选择不同的，相当于实例化对象时执行

示例代码

public class main {

    public static void main(String[] args) {

        //调用哪个取决于参数
        Person p1=new Person();
        System.out.println(p1.name);

        Person p2=new Person("蔡徐坤");
        System.out.println(p2.name);

        Person p3=new Person("吴亦凡",38);
        System.out.println(p3.name);
        System.out.println(p3.age);

    }


}

class Person{

    public String name;
    public int age;

    public Person(String name){
        this.name=name;
    }

    public Person(){
        this.name="往日情怀酿作酒";
    }

    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }

}

2.5 this关键字

只能写在类中方法中，但是不能是static修饰的方法--》可以是成员方法或构造方法

this 代指当前实例对象，等同与python的self，只不过python需要显示的传，而this不需要

示例代码其实前面都有，我就截个不能使用的图给大家看

2.6 访问控制修饰符

public protected public 访问权限控制修饰符

成员属性，成员方法，静态属性，静态方法中都可以被修饰

tips：friendly不能写出来，代表的是默认

1 private
用 private 修饰的类成员，只能被该类自身的方法访问和修改，而不能被任何其他类（包括该类的子类）访问和引用。因此，private 修饰符具有最高的保护级别

2 friendly（默认）
如果一个类没有访问控制符，说明它具有默认的访问控制特性。这种默认的访问控制权规定，该类只能被同一个包中的类访问和引用，而不能被其他包中的类使用，即使其他包中有该类的子类。这种访问特性又称为包访问性（package private）

3 protected
用保护访问控制符 protected 修饰的类成员可以被三种类所访问：该类自身、与它在同一个包中的其他类以及在其他包中的该类的子类。使用 protected 修饰符的主要作用，是允许其他包中它的子类来访问父类的特定属性和方法，否则可以使用默认访问控制符。

4 public
当一个类被声明为 public 时，它就具有了被其他包中的类访问的可能性，只要包中的其他类在程序中使用 import 语句引入 public 类，就可以访问和引用这个类

2.7 静态变量和静态方法

也就是我们说的static 这里给出定义

在类中，使用 static 修饰符修饰的属性（成员变量）称为静态变量，也可以称为类变量，常量（final）称为静态常量，方法称为静态方法或类方法，它们统称为静态成员，归整个类所有。

静态成员不依赖于类的特定实例，被类的所有实例共享，就是说 static 修饰的方法或者变量不需要依赖于对象来进行访问，只要这个类被加载，Java 虚拟机就可以根据类名找到它们

********************静态变量*************************
类的成员变量可以分为以下两种：
静态变量（或称为类变量），指被 static 修饰的成员变量
实例变量(对象变量)，指没有被 static 修饰的成员变量

********************静态方法********************
类的成员方法也可以分为以下两种：
静态方法（或称为类方法），指被 static 修饰的成员方法
实例方法（对象的方法），指没有被 static 修饰的成员方法

前面说的这么多，大家肯定都迷糊了，这里小小的总结一下

1 类 class 定义的
2 对象类实例化得到 ---》Person p =new Person();
3 属性，在类内部定义的变量:成员变量，静态变量，常量
   class Person{
String name; // 成员变量--》对象的
static String school // 静态变量--》类来用的（对象也可以用）
final int age=100 ; // 常量--》给对象用的常量
static final int xx=88;// 常量--》给类用的常量

}

4 方法:成员方法，静态方法
       class Person{
        public void showName(){ // 成员方法

}
public static void showName1(){ // 静态方法

}
}
5 构造方法:类实例化自动触发
   Person p =new Person(); //自动触发构造方法
   class Person{
    public Person(){ // 无参构造方法
}
}
6 静态属性静态方法刚刚讲过了

三.继承

继承也是面向对象中十分重要的部分

Java中的继承，只支持单继承，不支持多继承，但支持实现多个接口

3.1 继承的格式

在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的，一般形式如下：

class 父类 {
}

class 子类 extends 父类 {
}
class 子子类 extends 子类 {
}

上一节其实已经给过示例代码了，这一节在上一节讲过的地方主要讲个概念，就不给出示例代码了，望理解

3.2 构造方法

这里十分的绕，绕的简直离谱！特别重要！

1 子类如果没写构造方法，默认使用父类无参构造
2 子类如果没写构造方法,不会自动使用父类的有参构造
3 如果父类中，只有有参构造，子类中必须写构造方法，并且要使用super调用父类的有参构造
-父类的构造函数必须要被调用
-子类的构造函数中的调用

读吧绕死了！这里重点和大家说一下，别着急，一个个来

1 子类如果没写构造方法，默认使用父类无参构造（这里给出截图让你们好理解，最后会发一个代码整合）

这个就是没子类没构造方法，使用父类的无参构造

2 子类如果没写构造方法,不会自动使用父类的有参构造

可以看出这个，父类是有参构造，子类不写就会报错

3 如果父类中，只有有参构造，子类中必须写构造方法，并且要使用super调用父类的有参构造

可以发现必须要调用super，这个就相当于调用父类中的方法，一会会重点讲这个

3.3 super和this关键字

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类
-1 super 放在构造方法中使用户：代指父类super("名字")--->父类()--->Animal()
-2 super代指父类对象---》父类对象.Speak()-->调用父类的Speak方法--》重写的方法：可以在父类方法上下加功能，或纯自己重写

this关键字：指向自己的引用

这里代码有点长，截图接不下，大家看看理解一下

public class main {
    public static void main(String[] args) {
        //子类如果没写构造方法，默认使用父类无参构造
        Cat cat1=new Cat("小野猫");
        System.out.println(cat1.name);
        cat1.speak();
    }
}
class Animai{
    String name;
    public Animai(String name){
        this.name=name;
    }
    public void speak(){
        System.out.printf("%s说话了\n",this.name);
    }
}
class Cat extends Animai{
    public Cat(String name) {
        //super代表调用父类的方法
        super("");
        //这里写上自己想写的代码
        this.name=name;
    }

    public void speak(){
        //super代表父类对象
        super.speak();
        //这个是基于父类创建的 相当于可以再再此基础上重写
        System.out.println("喵喵喵");
    }
}

运行截图

四.重写和重载

上一节粗略的讲过，这里给出定义就好

1 重写(Override)是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写
-必须有继承关系

2 重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同
-被重载的方法必须改变参数列表(参数个数或类型不一样)
-可以没有继承关系

五.接口

这里给出接口的介绍

1 java 不支持多继承，有情况下我们要重写的方法，在多个类中，就可以使用接口来实现类似于多继承的功能
# python中
class Animal:
def run():
pass
class B:
def speak():
pass
class Person(Animal,B):
# 自带run和speak
java 中没有多继承
接口 Animal：run方法，方法内不能写代码
接口 B：speak方法，方法内不能写代码
class Person 实现Animal和B接口---》Person就有run和speak

2 接口不是类，不能被实例化

3 接口中方法没有具体实现---》接口中方法是由实现接口的类来具体实现的

4 接口只是为了规范子类的行为（方法）
-规定了子类必须有xx方法
-没有具体实现

5.1 接口的声名

[可见度] interface 接口名称 [extends 其他的接口名] {
// 声明变量
// 抽象方法
}

public class main {
    public static void main(String[] args) {

        Cat cat1=new Cat();
        cat1.run();

    }
}

interface Animal01{
    public void run();
}

interface Animal02{
    public void speak();
}


class Cat implements Animal01,Animal02{


    @Override //自动生成可以不写
    public void run() {
        //这里面写代码
    }

    @Override
    public void speak() {
        //这里面写代码
    }
}

5.2 接口的继承

接口可以继承接口用extends 其中，实现的类中要实现继承中的两个方法

public class main {
    public static void main(String[] args) {

        
    }
}

interface Animal01{
    public void run();
}

interface Animal02 extends Animal01{
    public void speak();
}

class Cat implements Animal02{
    
    //必须实现两个接口中的方法
    
    @Override
    public void run() {
        
    }
    
    @Override
    public void speak() {

    }
}

六.抽象类

抽象类，主要作为了解就行，其实和接口挺像的，抽象类主要是用来继承的，用abstract修饰

里面的抽象方法，也要用abstract修饰。

public class main {
    public static void main(String[] args) {
        

    }
}

abstract class Animal{ //抽象类主要是用来继承的

    //抽象类中的抽象方法，不需要具体实现
    public abstract void spqak();

    //抽象类中的抽象方法，有具体实现
    public void run(){
        System.out.println("跑跑跑");
    }

}

class Cat extends Animal{

    //抽象类中的方法必须实现
    @Override
    public void spqak() {
        
    }
}

七.封装

java中一般不直接通过对象调用属性，而是通过方法来设置和获取属性【更安全】
- 之前这么用person.name，是不被推荐的
------这种是常见的-------
- person.setName("往日情怀酿作酒")
- person.getName()

代码如下

public class main {
    public static void main(String[] args) {

            Animal cat=new Animal("咪咪");
            System.out.println(cat.getName());
            //一般都不直接写 cat.name 不安全
            cat.setName("丧彪");
            System.out.println(cat.getName());
    }
}

class Animal{ //抽象类主要是用来继承的

    String name;

    public Animal(String name){
        this.name=name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }




}

运行截图

八.多态

什么是多态?

多态是同一类事物[实例，对象]多种形态，从而调用同一类[实例，对象]方法时，表现出不同
   -什么算同一类？
   - 继承同一个父类
- 实现同一个接口
-多种形态？
   动物这一类：有小野猫，蔡徐坤人

-属于同一类：有共同的方法
   动物，都能走路和说话
小野猫，张三这个人，都能走路和说话
人是人走路，狗是狗走路

8.1 通过继承实现多态

代码如下

public class main {
    public static void main(String[] args) {
        //通过继承实现多态
        Cat cat=new Cat();
        Person caixukun=new Person();

        // 多态---》不管具体类型是什么(Person,Cat)-->都当Father用
        Animal f1=cat;
        Animal f2=caixukun;

        //表现不一样，具体类型不一样
        f1.speak();
        f1.run();

        f2.speak();
        f2.run();

        // 在不考虑对象具体类型情况下使用对象--》就把它统一当父类的对象使用



    }
}

class Animal{

    public void speak(){
        System.out.println("动物说话的方法");
    }

    public void run(){
        System.out.println("动物跑的方法");
    }
}

class Cat extends Animal{

    public void speak(){
        System.out.println("小野猫说话的方法");
    }

    public void run(){
        System.out.println("小野猫跑的方法");
    }

}

class Person extends Animal{

    public void speak(){
        System.out.println("蔡徐坤说话的方法");
    }

    public void run(){
        System.out.println("蔡徐坤跑的方法");
    }

}

8.2 通过接口实现多态

public class main {
    public static void main(String[] args) {

        Animal cat=new Cat();
        cat.run();
        cat.speak();
        
        Animal Caixukun=new Person();
        Caixukun.speak();
        Caixukun.run();

    }
}

interface Animal{
    void run();
    void speak();
}

class Cat implements Animal{

    @Override
    public void run() {
        System.out.println("小野猫跑咯");
    }

    @Override
    public void speak() {
        System.out.println("小野猫说话咯");
    }
}

class Person implements Animal{

    @Override
    public void run() {
        System.out.println("kunkun跑咯");
    }

    @Override
    public void speak() {
        System.out.println("kukun说话咯");
    }
}

tips:Object 类，所有类的父类
所有类的对象，都可以赋值给Object类的对象
这就是多态，把所有对象，都当成Object对象来用了