0004-类

廉某某

已于 2022-03-23 16:05:29 修改

阅读量627

点赞数

分类专栏： java学习文章标签： java tomcat

于 2022-03-23 00:24:54 首次发布

本文链接：https://blog.csdn.net/weixin_44345790/article/details/123675270

版权

java学习专栏收录该内容

6 篇文章 0 订阅

订阅专栏

类class

Java中类是描述事物的基本单位

类的声明部分 class+类名

类体 {}

类，方法，变量本质上来说都是一样的，只是容纳的东西不同。

方法容纳的代码块加变量，变量容纳的数据，类是最高级的容器，放的变量和方法。

首先得声明一个变量，然后对变量进行初始化。

方法的声明部分和方法体

类的声明和类体（类名遵循驼峰命名法）

class Person{
    //属性 成员变量，实例变量
    String name;
    int age;
    int height;
    int weight;
    
    /**车的属性
    String brand;
    String color;
    int price;
    */
    Car car; //前提是必须有Car这个类  ，表示人有一辆car
    //引用数据类型有数组，类，接口
    //类被创造出来就是为了描述某一个事物，不能做具象化分析
}


//抽象出car类
class car{
    String brand;
    String color;
    int price;  //假如放车轮，可否？ 车轮是组成部分
    //可以加车轮，但是要有车轮的数据类型   
}

对象(实例 instance)

概念变成实例，抽象变成具象的表达，必须要有内存空间和具体的数据表达

new 实例化，跟内存申请空间，

//概念变成具象化的，需要一块存储数据的空间

new Person（）; //new之后，在内存（堆）中申请空间，在堆中的属性一定有默认值。  
//引用数据类型默认值null，基本数据类型默认值0
//new过程叫做实例化，指向常量池，叫做初始化。
//局部变量在栈帧中
//new之后，根据属性初始化。

类如果要被运行，必须要有main方法，只要方法被执行就会有栈帧。

main方法是可执行程序的入口

第一个入栈的是main方法，栈底是main方法，先进后出

在这里插入图片描述

（1）建一个Person类，直接运行

class Person {
	
    String name;
    int age;
    int height;
    int weight;
    
    public static void main(String arg[]){
        System.out.println("程序开始");
            
        Person p1 = new Person();
        //对Person 进行实例化，局部变量p1
        
        System.out.println(p1.name);//点  直接调用他的属性
        System.out.println(p1.age);
        System.out.println("程序结束");
    }
}

在这里插入图片描述

在java程序的根目录下编译，注意utf-8编码和中英文符号

（2）建一个Person类和Test类（分开写）

//Person类，如果直接运行会报错
class Person {
	
    String name;
    int age;
    int height;
    int weight; 
} 

//Test类 （单独将main方法放出来）
class Test {
	
	   public static void main(String arg[]){
        System.out.println("程序开始");
            
        Person p1 = new Person();
        //对Person 进行实例化，局部变量p1
        
        System.out.println(p1.name);//点  直接调用他的属性
        System.out.println(p1.age);
        System.out.println("程序结束");
    }
}

在这里插入图片描述

栈和堆

堆栈：是一种数据结构，存放在内存中，是程序运行时用于存放的地方。

栈：主要存放已知固定的大小变量（简单类型变量：字符串、数值、布尔值）

堆：主要存放不能固定大小的变量值（如对象、数组）

new完之后，相当于在内存中开辟一块空间，实际上这时候已经有默认值了，然后对对象进行初始化。

初始化靠的构造方法

构造方法/构造函数/构造器 constructor

Person类

class Person {
    String name;
    int age;
    int height;
    int weight; 
    
    void get(){ //void方法没有返回值
        
    }   
    //构造方法是一个特殊的方法，作用是对实例对象进行初始化，实际上就是对这些数据初始化。
    //特点（1）方法名和类名完全一致（2）构造方法不需要返回值类型，而不是没有
    //本身的作用是只做初始化，对该类的实例进行初始化 
  
    
    //无参的构造方法，括号里面没有参数
    Person(){ //方法 缺少返回值
        System.out.println("Person类的构造方法");
    }
  
}

Test类

//Test类 （单独将main方法放出来）
class Test {
	
	   public static void main(String arg[]){
        System.out.println("程序开始");
            
        Person p1 = new Person();
        //对Person 进行实例化，局部变量p1
        
        //new之后才调用构造方法
        
        System.out.println(p1.name);//点  直接调用他的属性
        System.out.println(p1.age);
        System.out.println("程序结束");
    }
}

在这里插入图片描述

构造方法是对实例对象进行初始化，无法手动调用。

说明构造方法无法手动调用，系统自动调用，一般搭配new关键字对new出来的实例进行初始化

任何一个类可以没有方法，没有属性，但一定有构造方法，因为系统会自动提供一个无参的构造方法（前提是类中没有新的构造方法被声明）

只要写过构造方法，系统将不会提供无参的构造方法

（1）---------------------------

Person类

class Person {
    String name;
    int age;
    int height;
    int weight; 
    //构造方法  对实例对象进行初始化
    Person(){  //  只有在new出来的实例化之后才能被调用
        System.out.println("Person类的构造方法");
        name="张三";
         }
     
    //普通方法 ，实例方法  //操作对象的属性
        void print(){  
         System.out.println(name); //只有实例才能调用方法   
        }  
} 


//print 方法出现一定跟实例绑定在一起，在new之后，先申请空间，再初始化有值

Test类

//Test类 （单独将main方法放出来）
class Test {
	
	   public static void main(String arg[]){
        System.out.println("程序开始");
            
        Person p1 = new Person();
        //对Person 进行实例化，局部变量p1
        
        //new之后才调用构造方法
        p1.print(); //通过实例调用方法
           
           
        System.out.println(p1.name);//点  直接调用他的属性
        System.out.println(p1.age);
        System.out.println("程序结束");
    }
}

在这里插入图片描述

（2）----------------

Person类

class Person {
    String name;
    int age;
    int height;
    int weight; 
    //构造方法  对实例对象进行初始化
    Person(){  //  只有在new出来的实例化之后才能被调用
        System.out.println("Person类的构造方法");
        name="张三";
         }
     
    //普通方法 ，实例方法  //操作对象的属性
        void print(){  
         System.out.println(name); //只有实例才能调用方法   
        }  
    
    void setName(String n){
        name=n;
    }
    
}

Test类

//Test类 （单独将main方法放出来）
class Test {
	
	   public static void main(String arg[]){
        System.out.println("程序开始");
            
        Person p1 = new Person();
        //对Person 进行实例化，局部变量p1
        
        //new之后才调用构造方法 //通过实例调用方法  
        p1.print();  //张三
        p1.setName("1111");//1111
 
           
        System.out.println(p1.age);
        System.out.println("程序结束");
    }
}

(3)有参的构造方法

错误示范

class Car {
  String brand;
  int speed=2000;
  String color;
   
  //有参数的构造方法 brand,color
  Car(String b,String c){
	  brand=b;
	  color=c;
  }  
    
  //方法，汽车的功能
  void run(){
	  System.out.println("正在行驶");	 
  }
  
  public static void main(String args[]){
      
	  Car car = new Car(); 
      
	  car.run(); //调用方法
  } 
 
}

运行出错，报错如下。
原因:只要写过构造方法，系统将不会再提供无参的构造方法。所以程序实例化的时候要有参数，否则不能实例化
在这里插入图片描述

在这里插入图片描述

正确写法

class Car {
  String brand;
  int speed=2000;
  String color;
   
  //有参数的构造方法 brand,color
  Car(String b,String c){
	  brand=b;
	  color=c;
  }  
    
  //方法，汽车的功能
  void run(){
	  System.out.printf("%s的%s正在行驶\n",color,brand);	 
  }
  //printf 格式化输出
    
  public static void main(String args[]){
      
	//Car car = new Car("",""); 
    //左边 对Car的引用，右边 Car的实例对象  
    //int i=10  类似，不过一个基本数据类，一个引用数据类型  
    Car car = new Car("宝马","黑色"); 
	car.run(); //调用方法
     
    Car car1 = new Car("宝马","黑色"); 
	car1.run(); //调用方法
      
      
  } 
 
}

在这里插入图片描述

注意printf和println

\n 表示换行

print printf println区别

print为一般输出，同样不能保留精度格式转化，也不能换行输出
printf常用于格式转换，但需要注意不是换行输出，只用于精度转
println为换行输出，不能用于格式转换

This

this是个指向，指向当前对象，哪个对象调用的，就指向哪个

所有构造方法和实例方法（通过对象调用的）内部都有this

程序运行分析

class Car {
  String brand;
  int speed=2000;
  String color;
   
  //有参数的构造方法 brand,color
  Car(String b,String c){
	  brand=b;
	  color=c;
      /**实际上是
      this.brand=b;
	  this.color=c;
      */
      //方法的栈帧部分有this指向
      
  }  
    
  //方法，汽车的功能
  void run(){
	  System.out.printf("%s的%s正在行驶\n",color,brand);	 
  }
 
    
  public static void main(String args[]){     
    Car car = new Car("宝马","黑色"); 
	car.run();     
    Car car1 = new Car("宝马","黑色"); 
	car1.run();           
  } 
 
}

执行完毕之后，弹栈，从上往下，里面的引用全部消失，堆中属性对应常量池数值。Car的实例初始化完成。

接着，在main方法创建一个Car对象。

static 静态方法，不会通过对象调用。

成员变量在堆中，局部变量在栈中。

在这里插入图片描述

方法

实例方法/成员方法/对象方法

只有实例方法才能调用该方法

包

运行程序，读根目录下面的 .class文件

package声明类的位置

 package 包名；
     class Person{
         
     }

在cmd中执行，全类名(其实就是路径) java JavaLesson.test.Person.java

建文件夹com lwz java lesson1

package com.lwz.java.lesson1; //全类名，绝对路径
class Student{
    
}

跨包 import，声明类的位置

import告诉jvm引用的class文件的具体位置

import   com.lwz.java.lesson1; //全类名
import   com.lwz.java.*;  //包下面所有的类

public

public修饰的类，公开的，只要写了public，文件名和类名必须完全一致

方法重载

同一个类中，方法名完全一致，参数列表不同（个数，类型，顺序），与返回值无关

class Car{
    String brand;//局部变量
    
    //无参的构造方法
    Car(){
        System.out.println("无参的构造方法");
    }
    
    //有参的构造方法
    //将局部变量的值赋值给成员变量
    Car(String brand){
        this.brand=brand;//this指向当前构造方法的对象
        //左边是成员变量，右边是局部变量，
		System.out.println("有参的构造方法");
		
    }
      
    
    public static void main(String args[]){
        Car car= new Car();
        Car car1= new Car("111");
		System.out.println(car.brand);
        System.out.println(car1.brand);
		
    }
      
    
}

随着方法不同，无参就调用无参方法，有参调用有参方法

方法的调用需要的要素方法名和参数列表

例子

(1)void a(){  }
(2)void a(String s){  }
(3)void a(String sname,String s){  }
(4)void a(float f){   }
(5)void a(float f,String sname){   }
(6)void a(String sname,float f){   }  


//同一个类中，方法名完全一致，参数列表不同（个数，类型，顺序），与返回值无关

this （）指向，初始化必须在第一行。放后面会被覆盖。

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


改为this指向
class Person{
    String name;
    int age;
    String sex;
    
    Person(){
        this(null);
    }
    
    Person( String name){
        this(name,0);
    }
    
     Person( String name,int age){
         this(name,age,null);
        
    }
    
     Person( String name,int age, String sex){
           this.name=name;
           this.age=age;
           this.sex=sex;
        
    }
      
}

idea配置

在这里插入图片描述

设置快捷键

在这里插入图片描述

设置背景颜色，字体等

idea设置自动生成作者日期等注释

File=》Editor=》File and Code Templates=》File Header=》自己设置模板样式

参考模板样式：

/**
 * @Author: lmm
 * @Date: ${DATE} ${TIME}
 * 类说明
 * 目标
 * 关键方法
 * @Version 1.0
 */

Idea介绍

lang基础包，util高级包
在这里插入图片描述

ctrl+0 显示所有的方法
在这里插入图片描述

idea直接上传到git的方法

快捷键 psvm sout，然后回车会自动补充

### idea配置
设置背景颜色，字体等
## idea设置自动生成作者日期等注释
File=》Editor=》File and Code Templates=》File Header=》自己设置模板样式
参考模板样式：
/**
 * @Author: lmm
 * @Date: ${DATE} ${TIME}
 * 类说明
 * 目标
 * 关键方法
 * @Version 1.0
 */

ctrl+0 显示所有的方法

idea直接上传到git的方法

快捷键 psvm sout，然后回车会自动补充

廉某某

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
0004-类

类classJava中类是描述事物的基本单位类的声明部分 class+类名类体 {}类，方法，变量本质上来说都是一样的，只是容纳的东西不同。方法容纳的代码块加变量，变量容纳的数据，类是最高级的容器，放的变量和方法。首先得声明一个变量，然后对变量进行初始化。方法的声明部分和方法体类的声明和类体（类名遵循驼峰命名法）class Person{ //属性成员变量，实例变量 String name; int age; int height; int we
复制链接

扫一扫