Java--面向对象_上

Fly&L

已于 2022-02-13 12:23:32 修改

阅读量465

点赞数

分类专栏： java 文章标签： java 开发语言后端

于 2022-02-10 18:17:43 首次发布

本文链接：https://blog.csdn.net/weixin_45761101/article/details/122862317

版权

java 专栏收录该内容

9 篇文章 1 订阅

订阅专栏

包、类

包：把接近的类，规划在同一个包下。
1、在最开始的地方声明该类所处于的包名。如：pacage ospf；
2、使用其他包下的类，必须用import。
如 import ospf.lsa(ospf为其他包，lsa为ospf中的类）

类：class 类名
对象就是类中的一个具体事物。

java 是由类组成。
类中包含对象、方法、变量（属性）…

对象：每当使用new 构造函数去创建对象的时候，就会开辟一块堆内存地址空间。这个对象可以去调用类变量或这类方法来成为自己的属性值和方法。
在这里插入图片描述
注意：java内存分为两种，一种是堆内存，一种是栈内存。其中栈内存用来存放基本类型的变量和对象引用的变量。堆内存用来存放new创建的对象和数组。

数据类型

变量的数据类型：基本数据类型、应用数据类型。
基本数据类型：
整型：byte、short、int 、long
浮点型：float 、double
字符型：char类型用于存放一个字符，值用单引号’’(双引号表示字符串)
boolen：表示真和假
引用数据类型：
引用的概念，如果一个变量的类型是类类型，而非基本类型，那么该变量又叫做引用。
String、类：class 、接口：interface、数组、集合
在这里插入图片描述
例如：Hero h1 = new Hero();

变量定义格式

语法格式：  
修饰符 类型 属性名=初值;
（类属性初始值可写可不写；局部变量必须写且不加修饰符）

修饰符
属性是用来访问和继承的，修饰符是用来限定同包和不同包。

private ：只能自己类访问，不可以继承

不写：同包访问和继承，不同包不可以访问继承

protect：同包访问、继承。不同包不可以访问

public：放开

如何挑选合适符？（作用范围最小原则）
1. 属性通常使用private封装起来
2. 方法一般使用public用于被调用
3. 会被子类继承的方法，通常使用protected

类属性和类方法

变量的定义是：用来命名一个数据的标识符

类属性

类属性被声明在一个类下面，所以其作用域就是从其声明的位置开始的整个类

类属性范围：方法之外，本类当中
1、实例变量：不加static修饰（访问：创建对象-》对象.属性 ）。
2、类变量：加static修饰（访问：类名.属性 ）。

在这里插入图片描述
其中可以通过对象修改类属性：如dog.color=“yellow”；下面的color值就会改成yellow，不再是white。
属性初始化：
对象属性初始化有3种

声明该属性的时候初始化
构造方法中初始化
初始化块

类属性初始化有2种

声明该属性的时候初始化
静态初始化块

在这里插入图片描述

类方法

何时使用实例方法和类方法？

实例方法：这个方法需要对象才能体现意义时候。
类方法：所有对象都需要的动作时候。

在这里插入图片描述

数据类型转换

基本类型转换
在这里插入图片描述
虽然short和char都是16位的，长度是一样的
但是彼此之间，依然需要进行强制转换

对象转型

Animal  dog=new Animal()
引用dog的类型为Animal
对象new Animal()的类型也为Animal
当对象和引用的类型不一样时需要需要转换

一、子类转父类（向上转型）

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

        Dog daHuang=new Dog();  //父类
        Animal xiaoHuang=new Animal(); //子类
        
        daHuang=xiaoHuang;      //子类转父类可以
        
        xiaoHuang=(Animal)daHuang;  //父类转子类需要强制
                                   
    }
}

二、父类转子类（向下转型）

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

        Dog daHuang=new Dog();  //父类
        Animal xiaoHuang=new Animal(); //子类
        
        xiaoHuang=daHuang;      //父类直接转子类报错
        
        xiaoHuang=(Animal)daHuang;  //父类转子类需要强制
                                   
    }
}

三、没有继承关系的转换一定报错
四、实现类转成接口可以成功；接口转成实现类失败
五、使用instanceof判断引用指向的对象类型

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

        Dog daHuang=new Dog();  //父类
        Animal xiaoHuang=new Animal(); //子类

        Dog xiaoHuang_1=xiaoHuang;
        System.out.println(xiaoHuang instanceof Dog);  //输出为true
    }
}

其他变量

1、参数：在方法中的变量，方法结束变量销毁

参数的作用域即为该方法内的所有代码，其他方法不能访问该参数,类里面也不能访问该参数
形参（方法签名中定义的变量）

2、局部变量
其作用域在声明开始的位置，到其所处于的块结束位置

方法局部变量（方法内部定义）
代码块局部变量（在代码块{ }）

3、引用
引用就是java中保存地址的变量，在堆内存当中使用. 进行访问， . 之前的就是引用（就是在堆内存当中进行操作）， .之后的就是对象的实例方法或者实例变量。

常见关键字

static：
静态成员=static+变量：
Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问。
静态方法=static+方法：
被 static 修饰的方法是静态方法，静态方法不依赖于对象，不需要将类实例化便可以调用，由于不实例化也可以调用，所以不能有 this，也不能访问非静态成员变量和非静态方法。但是非静态成员变量和非静态方法可以访问静态方法。

final：修饰变量，修饰方法、修饰类
final 关键字可以修饰类、方法、属性和变量
final 修饰类：则该类不允许被继承，为最终类
final 修饰方法：则该方法不允许被覆盖（重写）
final修饰变量：该变量只有一次赋值的机会

public class HelloWorld {
    public void method1() {
        final int i; 
        i = 10; //i在第4行，只是被声明，但是没有被赋值，所以在这里可以进行第一次赋值
        
        i = 11; //i在第6行已经被赋值过了，所以这里会出现编译错误     
    }
}

this
this 关键字代表当前对象。使用 this.属性 操作当前对象的属性。this.方法 调用当前对象的方法。

public class Secondy {
    String name;
    float hp;
    float armor;
    int moveSpeed;
    
     public void showAddressInMemory(){
        System.out.println("打印this看到的虚拟地址"+this);
    }

    public static void main (String [] args){
        Secondy h =new Secondy();
     
        h.name="盖隆";
        System.out.println("打印h看到的虚拟地址"+h);
        h.showAddressInMemory();
    }
}

通过this访问属性
在这里插入图片描述
如果要在一个构造方法中，调用另一个构造方法，可以使用this()

super
关键字在子类内部使用，代表父类对象。

访问父类的属性 super.属性名。
访问父类的方法 super.bark()。
子类构造方法需要调用父类的构造方法时，在子类的构造方法体里最前面的位置：super()。

方法

方法：是对象具体操作的动作。

普通方法

修饰符 返回值类型 方法名（形参类型1，参类型2，参数类型3..{

return 返回值
}

形参：基本类型（int.double…)和类类型（引用）。
实参：实际传给形参的数据变量（实际数字或者变量，例如1,2,3…）。

package first;
public class Oneday{

    String name;
    float hp;
    int  armor;
    int moveSpeed;
    // 有返回值
    float getArmor(){
        //System.out.println("armor");
        return armor ;

    }
    // 无返回值
    void keng () {
        System.out.println("keng");
   }
   //带参数
    void addSpeed(int speed){
        moveSpeed=moveSpeed+speed;
        System.out.println(moveSpeed);
   }

   public static void main(String[] args){
        Oneday One=new Oneday();
        One.name="firstday";
        One.moveSpeed=350;
        One.addSpeed(100);

    }
}

注意：
1、返回值就是通过方法得到的数据。
2、当返回值类型为void时不用写返回值。
3、方法之中可以调用方法但是不可以定义方法。
4、同一个类当中可以直接调用，不用new去实例化。

构造方法

每个类都有构造方法在创建该类的对象的时候他们将被调用，如果没有定义构造方法，Java 编译器会提供一个默认构造方法。创建一个对象的时候，至少调用一个构造方法。比如在新建一个对象 new Object()，括号中没有任何参数，代表调用一个无参构造方法（默认构造方法就是一个无参构造方法）。构造方法的名称必须与类名相同，一个类可以定义多个构造方法

public class People{

//无参构造方法
public People(){

}
//有一个参数的构造方法
public People(int age){

}
}

public class People {
 //属性（成员变量）有什么
double height;     //身高
int age;           //年龄
int sex;       //性别，0为男性，非0为女性

//构造函数，初始化了所有属性
public People(double h, int a, int s){
    height = h;
    age = a;
    sex = s;
}
}

//创建对象，调用我们自己定义的有参构造方法
People XiaoMing = new People(168, 21, 1);

上面的例子中通过 new 关键字将类实例化成对象，而 new 后面跟的就是构造方法。于是可以知道 new + 构造方法可以创建一个新的对象。
构造方法的两个作用：
1.创建对象
2.初始化实例变量。

方法重载

方法重载是指在一个类中定义多个同名的方法，但是参数类型和参数个数不一样
重载的方法中允许抛出不同的异常
可以有不同的返回值类型，可以有不同的访问修饰符。
在这里插入图片描述
所以输出结果为盖伦攻击了提莫；因此attack方法里面的name值为盖伦

方法重写

子类可以继承父类的对象方法，在继承后，重复提供该方法，就叫做方法的重写
重写的方法需要保证返回值类型，参数类型及个数，和方法名都必须一致。

public class Dog {
  public void blak(){
      System.out.println("wangwang");
  }
}


public class Animal extends Dog {

    public  void blak(){
        System.out.println("动物叫声");
    }

    public static void main(String[] args) {

        Animal animal_1=new Animal();
        animal_1.blak();  //动物叫声

        Dog dog_1=new Dog();
        dog_1.blak();   //wangwang

    }
}

隐藏

与重写类似，方法的重写是子类覆盖父类的对象方法
隐藏，就是子类覆盖父类的类方法

public class Dog {
  static void blak(){
      System.out.println("wangwang");
  }
}

public class Animal extends Dog {

   static void blck  (){
          System.out.println("动物叫");
      }

    public static void main(String[] args) {
          Animal daHuang=new Animal();
          daHuang.blck ();

    }
}

传参

变量有两种类型 基本类型 和类类型
参数也是变量，所以传参分为

基本类型传参
类类型传参

基本类型传参

在方法内，无法修改方法外的基本类型参数
在这里插入图片描述

类类型传参
在这里插入图片描述

Fly&L

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java--面向对象_上

包、类包：把接近的类，规划在同一个包下。1、在最开始的地方声明该类所处于的包名。如：pacage ospf2、使用其他包下的类，必须用import。如 import ospf.lsa(ospf为其他包，lsa为ospf中的类）类：class 类名对象就是类中的一个具体事物。java 是由类组成。类中包含对象、方法、属性…变量变量的数据类型：基本数据类型、应用数据类型。基本数据类型：整型：byte、short、int 、long浮点型：float 、double字符型：c
复制链接

扫一扫