Java基础学习+面向对象（一）

已于 2024-01-24 11:45:07 修改
阅读量790 收藏 1
点赞数 1
分类专栏： Java 文章标签： java 学习 jvm
于 2023-06-06 16:23:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46065185/article/details/130942389
版权

一，基础概念介绍

1.1Java跨平台原理（一次编译，处处运行）

  • Java 源代码经过编译，生成字节码文件，交由 Java 虚拟机来执行，不同得系统有不同得JVM,借助JVM 实现跨平台。
  • 就比如说我们在 Windows 下面写出来的一段 Java 程序，换成 Linux，macOS 系统里面，一样可以正常运行并且输出相同的结果
  • Java 虚拟机（Java Virtual Machine，简称 JVM）是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。Java 虚拟机包括一套字节码指令集、一组寄存器、一个栈、一个垃圾回收堆和一个存储方法域。JVM 屏蔽了与具体操作系统平台相关的信息，使 Java 程序只需生成在 Java 虚拟机上运行的目标代码（字节码），就可以在多种平台上不加修改地运行。JVM 在执行字节码时，实际上最终还是把字节码解释成具体平台上的机器指令执行。
    在这里插入图片描述

1.2JRE与JDK

1.2.1JRE（Java Runtime Environment）

是Java程序的运行时环境，包含JVM和运行时所需的核心类库，我们想运行一个Java程序，只需要安装一个JRE即可。

1.2.2JDK(Java Development Kit)

是Java程序开发工具包，包含JRE和开发人员使用的工具，开发工具：编译工具（javac.exe），运行工具（Java.exe）在这里插入图片描述在这里插入图片描述
在这里插入图片描述

1.2.3Idea的使用

  • Idea的项目结构：

在这里插入图片描述

  • 新建模块

在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述
在这里插入图片描述

  • 删除模块
    选中要删除的模块，，右键选择remove module在这里插入图片描述

  • 导入模块
    查看模块所在目录：选中模块右键选择：在这里插入图片描述在这里插入图片描述
    导入模块：和创建模块类似：在这里插入图片描述

在这里插入图片描述
找到模块路径即可：在这里插入图片描述

1.3基础知识

1.3.0变量|常量名称定义原则：

  • 所有变量，方法，类名：见名知意
  • 类成员变量：首字母小写和驼峰原则：monthSalary
  • 局部变量:首字母小写与驼峰原则
  • 常量:全大写和下滑线分割：MAX_VALUE
  • 类名:首字母大写与驼峰原则：Man,GoodMan
  • 方法名:首字母小写和驼峰原则:run(),runRun()

1.3.1变量定义|作用域

（1）定义

  • 变量的本质（固定空间）：停车位,空间已经确定，但具体放置哪量车不确定。
  • 变量名（通过名字操作空间）：停车位编号
  • 数据（变化的量）：车

（2）作用域

  • 局部变量：从属于方法，作用范围：方法内部
  • 成员变量：从属于对象，位于类内部，方法外部，对象创建，成员变量创建，(对象可以直接调用类的成员变量)，对象消失，成员变量也跟着消失。
  • 静态变量：从属于类，static修饰，类加载时有效，类被卸载时，静态变量消失。
public class Demo1{
    //实例对象，作用范围在整个类中，可以不给初始值，会有默认值
    String name;
    int age=1;

    public static void main(String[] args) {
        /*局部变量，必须声明且初始化，作用范围只在函数中
        在add（）方法中不能调用*/
        int a=1;
        System.out.println(a);
        /*main中调用实例对象*/
        Demo1 demo=new Demo1();
        System.out.println(demo.age);
        System.out.println(demo.name);

    }
    /*其他方法*/
    public void add(){

    }
}

1.3.2注释|关键字

  1. 注释：单行注释”//注释信息“；多行注释：/注释信息/
  2. 关键字：字母全部小写，关键字颜色不同，一般高亮显示在这里插入图片描述

1.3.3. 常量定义

public class Demo02 {
    //常量定义一般用大写字母表示，且修饰符先后顺序无影响，static final或者final static都一样
    static final double PI=3.14;
    public static void main(String[] args) {
        System.out.println(PI);
    }
}

public class Demo01 {
    //类变量 加static
    static double salary=2500;//在main中可以直接输出
    //实例变量，从属于对象,必须由对象引用；
    String name;
    int age;
    //main方法
    public static void main(String[] args) {
        //局部变量，必须声明和初始化
        int i=10;
        System.out.println(i);
        //变量类型  变量名=new Demo01();
        Demo01 demo01=new Demo01();
        System.out.println(demo01.age);//如果age没进行初始化，会输出默认值0或者0,0.0
        System.out.println(demo01.name);//字符串默认16位0000，bool值默认false；除了八个基本类型，其余都是null;
        System.out.println(salary);

    }
    //其他方法，
}

在这里插入图片描述

在这里插入图片描述
注意：字符常量与字符串常量分别用的单引号和双引号

  System.out.println("Hello world！");//字符串常量
        System.out.println(5);//整数常量
        System.out.println(true);//布尔常量
        System.out.println('a');//字符常量
        //System.out.println(null);//空常量不可直接输出

1.3.4 数据类型及转换

在这里插入图片描述

```java
//整数
        byte num1=2;
        short num2=4;
        int num3=3;
        long num4=3l;//long类型后面要加l区分
        //小数
        float num5=1.4F;//float类型要加F区分
        double num6=3.1415926;
        //字符，字符串
        char name='A';//单引号
        String name2="中国";//双引号，String首字母大写
        //布尔型
        boolean flag=true;
        boolean flag2=false;

(1)自动类型转换：把一个表示数据范围小的数值或者变量 赋值给令一个表示数据范围大的变量（2）强制类型转换：可以将表示范围大的转小的：int K=(int)88.8

1.3.5算数运算符

加+，减-，乘*，除/，取余%，整数相除只能得到整数，想要得到小数，必须用浮点数运算

（1）整数进行运算

int a=6;
int b=4;
System.out.println(a+b);
System.out.println(a-b);
System.out.println(a*b);
System.out.println(a/b);
System.out.println(a%b);

（2）字符进行运算，'A’对应的值是65，'a’是97

 //字符参加运算
        char c='A';
        System.out.println(a+c);

在这里插入图片描述
（3）字符串的操作：加号起到连接的作用

  //字符串+操作
        System.out.println("hello"+"world");
        System.out.println("hello"+666);

在这里插入图片描述
特殊情况：如果数字在前先做加法，再与后面的进行拼接

   System.out.println("hello"+666+1);
   System.out.println(666+1+"hello");

在这里插入图片描述

1.3.6.关系|逻辑运算符

在这里插入图片描述
在这里插入图片描述
1.逻辑与&，逻辑或|运算

   int i=10;
    int j=20;
    int k=30;
    System.out.println((i>j)&(i>k));
    System.out.println((i>j)|(i<k));

在这里插入图片描述
2.逻辑与，逻辑或与短路与，短路或的区别：
（1）A&B，A|B:不管A是对是错，后面的B都会继续执行。
（2）A&&B:只要A错了，整体错，B就没必要执行了。
（3）A||B:只要A对，整体对，B也没必要执行了。在这里插入图片描述

1.3.7三元运算符

格式：关系表达式1？表达式1：表达式2；
如果关系表达式1的值为True:执行表达式1，否则执行表达式2.

1.3.8数据输入

（1）Python中数据输入是input()函数，可将输入值赋值给其他变量：name=input("请输入姓名：")
（2）Java中数据输入
导包：在这里插入图片描述
创建对象：接受数据

  Scanner sc= new Scanner(System.in);
        int i=sc.nextInt();
        System.out.println(i);

在这里插入图片描述
在这里插入图片描述

1.3.9综合案例：

1.输入三个和尚的身高并求出最高

import java.util.Scanner;
public class demo02 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        //输入三个和尚的身高
        System.out.println("请输入身高：");
        int height1=sc.nextInt();
        int height2=sc.nextInt();
        int height3=sc.nextInt();
        //利用三元运算符求最大身高
        int tempheight=height1>height2?height1:height2;
        int Maxheight=tempheight>height3?tempheight:height3;
        System.out.println(Maxheight);

    }
}

在这里插入图片描述

1.4控制语句

1.4.1if语句

Java中的if格式：

if(表达式){
语句体;
}

if(表达式){
语句体1;
}else{
语句体2;
}

if(表达式1){
语句体1;
}else if(表达式2){
语句体2;
}...
else{
语句体n+;
}

Python中的if格式：

if 表达式：
	语句体

if condition1：
    statment_block_1
elif condition2：
    statment_block_2
else：
    statment_block_3
 """  
如果 "condition_1" 为 True 将执行 "statement_block_1" 块语句
如果 "condition_1" 为False，将判断 "condition_2"
如果"condition_2" 为 True 将执行 "statement_block_2" 块语句
如果 "condition_2" 为False，将执行"statement_block_3"块语句

"""

1.4.2switch语句

Java中的switch：

switch(表达式){
case 值1：语句体1；break;
case 值2：语句体2；break;
case 值3：语句体3；break;
default: 语句体4；[break]//此处的break可有可无，执行到default语句后会自动退出
}

Python中的match case:

match subject:
    case <pattern_1>:
        <action_1>
    case <pattern_2>:
        <action_2>
    case <pattern_3>:
        <action_3>
    case _:
        <action_wildcard>

1.4.3While语句

while循环更适合于循环次数不明确的情况下：
Java语法结构：

while(条件判断语句){
循环体语句;
条件控制语句;
}

python语法结构:

while 判断条件(condition)：
	执行语句(statements)……

#end关键字，在输出print（）中，可以使输出元素在同一行，并用某符号隔开
a,b=0,1
while b<10:
    print(b,end=" " )#用空格隔开
    """print(b, end="，") 用逗号隔开隔开"""
    a,b=b,a+b

1.4.4for循环

Java语法结构：

for(初始化语句；条件判断语句；条件控制语句){
	循环体语句；
}

Python语法结构：

for 临时变量 in 待处理数据集:#每循环一次将待处理数据集中数据赋值给临时变量
    <statements>

sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
    print(site)

1.5Random

获取随机数：
使用方法：导包，创建对象，使用

import java.util.Random;

Random random=new Random();
int number=random.nextInt(10);//从[0-10)随机选一个数
System.out.println(number);

在这里插入图片描述

1.6数组Array

1.6.0内存分配与数组定义

在这里插入图片描述

  • 定义

一次性存储同类型的大量数据

  • 两种定义格式
    （1）数据类型【】 变量名
int[] arr//定义了int类型的数组，数组名是arr

(2)数据类型 变量名【】

int arr[]//定义了int类型的变量，变量名是arr数组
  • 动态数组初始化
    （1）动态初始化：初始化时候只指定数组长度，由系统为数组分配初始值，一般是0,使用new可以为数组申请内存空间
int[] arr=new int[3]
//定义了一个int类型的数组，数组名是arr，
//通过new为其申请内存空间，数组内存储三个int性变量

（2）数组内容访问
数组名【索引】：索引值从0开始指向第一个元素

package Array;

public class array_creat {
    public static void main(String[] args) {
        int[] arr=new int[5];
        System.out.println(arr);//输出数组的内存信息
        System.out.println(arr[0]);//输出第一个元素
    }
}

在这里插入图片描述
数组定义时的内存分配图：
在这里插入图片描述
取数组内数值时的内存图：
在这里插入图片描述
内存回收：栈内的数据使用完会立即被回收，堆不会立即回收
在这里插入图片描述

  • 数组静态初始化
    （1）在数组定义的时候就进行初始化，给定数组内部元素值
    （2）格式1：
数据类型[]变量名=new 数据类型[]{元素1，元素2，.....}
int[] arr=new int[]{1,2,3}

（3）格式2：

数据类型[]变量名={元素1，元素2，.....}
int[] arr={1,2,3}

1.6.1数组的遍历

当数组内部元素非常多，并且需要逐个输出是，就会用到遍历，通过

数组名.length

获取数组长度，以便在循环中用来控制循环次数。

int[] arr={.......};
for(int i=0;i<arr.length;i++)
{
	System.out.printlen(arr[i]);
}

1.7数组常出现的两个问题

  1. 索引越界：访问数组中不存在的索引对应的元素，造成索引越界问题 ArrayIndexOutOfBoundsException
  2. 空指针异常：访问的数组已经不指向堆内存数据，造成空指针异常NullPointerException
package Array;

public class array_exception {
    public static void main(String[] args) {
    /*    1. 索引越界：访问数组中不存在的索引对应的元素，造成索引越界问题
            ArrayIndexOutOfBoundsException
        2. 空指针异常：访问的数组已经不指向堆内存数据，造成空指针异常
            NullPointerException
            */
        int [] arr=new int[3];
        //System.out.println(arr[4]);
        arr=null;
        System.out.println(arr[0]);
    }
}

1.8方法

1.8.1方法定义与调用

  • 方法的定义：
public static void func_name(数据类型 参数名，....){
	//方法体
}

在这里插入图片描述

  • 方法的调用：
//方法名();
func_name(参数);
  • python中方法的定义格式：
def func_name():
	#方法体
  • 带有返回值的方法
package Function;

public class Func1 {
    public static void main(String[] args) {
       int max=Max_num(9,10);
        System.out.println(max);
    }
    //定义一个方法判断两个数值的最大值，并返回最大值
    public static int Max_num(int num1,int num2){
        if (num1>num2){
            return num1;
        }else {
            return num2;
        }
    }
}

在这里插入图片描述

1.8.2方法重载

  • 概念：方法重载是指在同一个类中定义的方法，参数类型和个数不同，方法参数类型顺序不同，但方法名相同。
  • 方法重载展示了同一个类中多个方法之间的关系。
//参数个数不同
add(int, int)
add(int, int, int)

参数类型不同
add(int, int)
add(int, float)

//参数顺序不同
add(int, float)
add(float, int)
  • 方法重载的无效情况：不能通过返回值类型是否相同判断其是否为方法重载
int add(int, int)
float add(int, int)

1.9Debug调试

1.加断点并运行，程序从断点处开始执行：
在这里插入图片描述
在这里插入图片描述在这里插入图片描述
2.调试：点击控制台的按钮step into（或F7）逐行执行，即使遇到方法调用的行也会进入方法中，如果使用第一个按钮：step over对于方法调用语句，不会进入方法内部。

在这里插入图片描述在这里插入图片描述在这里插入图片描述
3.停止Debug
在这里插入图片描述
取消断点，可再次点击一次：
如果断点比较多可通过以下方式：
在这里插入图片描述在这里插入图片描述

2.0方法调用出错案例

  1. 定义一个计算器方法和对计算结果取余的方法：

（1）定义计算器方法：

 public static int calculator(int a,int b,String f){
        switch (f){
            case "+":
                return a+b;
                break;
            case "-":
                return a-b;
                break;
            case "*":
                return a*b;
                break;
            case "/":
                return a/b;
                break;
            default:
                return 0;
        }

在这里插入图片描述
出现报错：出错原因：由于方法中当执行return以后就认为已经结束了，后面的代码已经没有任何意义了。
在这里插入图片描述
解决方法：将switch中的break都删掉
在这里插入图片描述
此时可能会有疑问：当switch中没有break会不会从第一个匹配值一直往下运行？
答案：如果单独使用switch且没有break，确实会出现此情况，但此时switch在方法体中，当匹配到对应case后执行后面内容，然后遇到return语句，方法遇到return整个方法执行结束，则相应的方法体内部的switch也会随及停止，所以不会出现继续执行的情况。

package com.bipt.day04_Function;
/*定义一个计算器，并将运算结果对10取余*/
public class Demo01_Func_calculator {
    public static void main(String[] args) {
       int x=calculator(15,20,"+");
        mod(x);//输出5

    }
    //定义计算器函数
    public static int calculator(int a,int b,String f){
        switch (f){
            case "+":
                return a+b;
                //break;
            case "-":
                return a-b;
                //break;
            case "*":
                return a*b;
               // break;
            case "/":
                return a/b;
               // break;
            default:
                return 0;
        }
    }
    //定义取模函数
    public static void mod(int x){
        System.out.println(x%10);
    }
}

二，面向对象

2.0快捷键

  • 快捷键生成get()和set()方法，或构造方法：Alt+Insert在这里插入图片描述
  • 创建的对象调用某方法，左边需要赋值给某变量，先写调用，然后左边通过Ctrl+Alt+V自动生成。
package API;
import java.util.Scanner;
public class String_Scanner {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一串数据！");
        String line = scanner.nextLine();
        System.out.println("输入的数据是："+line);
    }
}

在这里插入图片描述

  • Alt+Enter：自动补全实例化对象。

2.0.1常量定义

（1）Java中最小的组织单元是类，所有的常量都必须定义在类中，不能像C++定义在类外（全局变量）

（2）且常量名大写，加关键字final

（3）定义好的常量后续创建对象时参数中如果用到直接用类名调用即可，类名.常量名
在这里插入图片描述

2.0.2static关键字

  1. static可以修饰属性（变量/常量）和方法，存在静态存储区，只要类存在既不会销毁，static定义的变量在内存中出现的更早，通过类名就可以访问，不像其他变量只有在创建对象后才能访问。

  2. static修饰的变量并不属于某个对象，其加载也早与对象，所以即使不创建对象也能通过类名进行调用

  3. 何时用？
    对于类中的一些变量如果只希望进行一次赋值，并且希望在类实例化之前就走一遍，就可以使用静态代码块

package com.bipt.Test.Static关键字;
/*
* */
public class Student {
    public static void main(String[] args) {
        Person.age=20;

        Person person1=new Person();
        person1.name="张三";//第一次定义后，后面的都是这个值，对于变量值相同的情况不需要么此实例化对象时重新赋值
        person1.fun1();

        Person person2=new Person();
        person2.fun1();
    }

}

class Person{
    static String  name;
    static int age;
    public void fun1(){
        System.out.println("姓名："+name+"年龄："+age);
    }

}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
4.(非静态/静态)代码块
非静态代码块

package com.bipt.Test.Static关键字;

public class Student02 {
    int age=20;
    public static double monery;

    //非静态代码块1
    {
        age++;
    }
    //非静态代码块2
    {
        monery=6000;
    }


}

package com.bipt.Test.Static关键字;
//测试类
public class Stu_test {
    public static void main(String[] args) {
        System.out.println(Student02.monery);
    }
}

在这里插入图片描述
创建对象后再调用

package com.bipt.Test.Static关键字;

public class Stu_test {
    public static void main(String[] args) {
        //System.out.println(Student02.monery);
        new Student02();//创建对象
        System.out.println(Student02.monery);
    }
}

在这里插入图片描述

输出结果时0.0，证明代码块中的赋值并没有进行，而归Student02类进行New之后再输出，才会有赋值，说明代码块中的内容时实例化对象的时候才会加载。

静态代码块
对于非静态的代码块，每新建一次对象（new一次）都会进行调用一次，而静态代码块只调用一次

package com.bipt.Test.Static关键字;

public class Student02 {
    int age=20;
    public static double monery;

    //非静态代码块
    {
        age++;
    }
    //非静态代码块2
    static 
    {
        monery++;
    }


}

package com.bipt.Test.Static关键字;

public class Stu_test {
    public static void main(String[] args) {
        //System.out.println(Student02.monery);
        //new Student02();
        System.out.println(Student02.monery);//类名直接调用代码块中的内容
        System.out.println(Student02.monery);

    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.0.3栈与堆

在这里插入图片描述
在这里插入图片描述
（1）new出来的在堆中开辟空间。GC回收机制的引用数等于1时证明该变量还存在，为0时考虑自动回收（不一定）

​（2）也可以主动让gc机制回收，

System.gc();

在这里插入图片描述

2.1类的定义及命名规则

  • 表示类名的标识符：每个单词首字母大写。
  • 表示方法和变量的标识符：”驼峰原则“。
  • 注：由于java不采用ASCLL字符集，而是Unicode字符集，因此这里字母含义不仅仅是英文，还包括汉字。（不建议用汉字）

定义学生类，Student类包含属性与方法

//学生类
public class Student {
    //属性
    String name;
    int age;
    //方法
    public void study(){
        System.out.println("学生");
    }
}

在这里插入图片描述
在这里插入图片描述
如何创建一个标准类：
在这里插入图片描述

2.2类实例化

  • Java中对象实例化格式：
  • Student类需要实例化才能使用，main函数中用new实例化，返回具体实例student

public class application {
    public static void main(String[] args) {
        //类是抽象的，需要实例化
        //类实例化后返回自己的对象
        Student student=new Student();
    }
}
  • 实例化出来的student可以具体给他的name和age赋值
public class application {
    public static void main(String[] args) {
        //类是抽象的，需要实例化
        //类实例化后返回自己的对象
        Student student=new Student();
        //具体赋值
         student.name="小红";
        student.age=20;
        System.out.println(student.age);
    }
}
  • python中类的实例化格式：不需要特意使用new关键字
class Student:
    name=None
    gender=None
    nationality=None#国籍
    native_place=None#籍贯
    age=None
#创建对象
student1=Student()
student1.name='张飞

2.3类的构造

  • 构造器和类名相同
  • 构造器的调用规则，及super，this关键字详解
    原本构造方法是默认存在，且不显示的，如果给出了一个有参构造，那么无参构造必须显示给出，因为在实例化对象时，不想给有参构造传参数，无参构造没有显示给出的话会报错。
    （1）以下是显示定义有参构造在这里插入图片描述
    测试类中实例化对象出错：
    在这里插入图片描述
    解决办法是给类添加参数：在这里插入图片描述
    （2）如果在实例化对象时，就是想使用无参构造，那么在定义类中必须显示给出无参构造函数，因为当定义了有参构造后，原本默认隐藏的无参构造就不起作用了。

在这里插入图片描述在这里插入图片描述

package Test_Demo;
//学生类
public class Student {

    String name;
    int age;
    //一个类即使什么都不写，也会存在一个方法
    //无参构造（显示构造器）
    public Student() {
    }
  
}//快捷键alt+insert选择constructor进行有参或无参构造

在这里插入图片描述在这里插入图片描述
总结：
在这里插入图片描述

2.3.1匿名内部类

在这里插入图片描述
在这里插入图片描述用接口的引用接收（指向）实现类对象：

在这里插入图片描述
在这里插入图片描述

2.3.1.0何时用？

在这里插入图片描述

2.4封装

封装是指将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法实现对隐藏信息的操作和访问成员变量private，提供对应的getXxx()/setXxx()方法。
在这里插入图片描述

2.4.1私有属性：Private

在项目实战中，为了数据的安全性考虑，我们一般都会隐藏代码实现细节，用private来修饰属性，使用private修饰其他类无法访问本类私有化的属性，一般来讲，get是取来值的方法，set是设置值的方法，因为get在英文中有取，拿的意思，而set有设置的意思，所以用源get，set能很形象的明白方法的目的，比如对于一个name属性，getName就是取出这个name的名称，而setName就是设置name的名称定义两个方法：分别是get（）和set（）方法，当外界需要使用私有成员变量时可以通过调用者两个方法：在这里插入图片描述
（1） 将Student类中的age改成私有之后，测试类中无法调用。在这里插入图片描述在这里插入图片描述

2.4.2使用set()和get()方法

在这里插入图片描述

 package test;
  
  public class Person01 {
  
     //用private来修饰属性
     private String name;
      private int age;
 
     //给属性添加get、set方法    
     public String getName() {
         return name;
     }
 
     public void setName(String name) {
         this.name = name;
     }
 
     public int getAge() {
         return age;
     }

     public void setAge(int age) {
        this.age = age;
    }

}

测试类：

  package test;
  
  public class Person02 {
  
     public static void main(String[] args) {
        //创建Person01对象
        Person01 p1 = new Person01();
         
         //现在我想给Person01的对象属性附上值  
          p1.name = "张三";  //不能这样赋值  如果给Person01里name的private修饰符去掉就可以这样赋值

         //通过set方法赋值
         p1.setName("张三");
         
         //是不是每一个set只能赋一个值  如果把Person01类的setAge()方法删掉，那这个就会报错
        p1.setAge(18);
         
        //这样拿不到值，会报错
   		// System.out.println("姓名："+p1.name+"\n年龄："+p1.age);
         
        //得通过get方法才能拿到
         System.out.println("姓名："+p1.getName()+"\n年龄："+p1.getAge());
        
    }
   
 }
　　结果：
　　姓名：张三
　　年龄：18

（3）当定义的私有成员比较多时，不方便一个个手敲，快捷键使用alt+insert：
在这里插入图片描述在这里插入图片描述
（4）例如私有成员变量age,可以在set()方法中设置判断语句，防止修改的年龄不符合正常数字，如负数：

   public void setAge(int age) {
        //this.age = age;
        if (age<0||age>120){
            System.out.println("输入年龄有误");
        }else {
            this.age=age;
        }
    }

2.5字符串

2.5.1API

Java API:指的是JDK中提供的各种功能的Java类，这些类将底层的实现封装了起来，我们不需要关心这些类如何实现，只需要学习这些类的使用即可，我们可以通过帮助文档来学习这些API.
举例：Scanner类的使用：
在这里插入图片描述
部分方法：
在这里插入图片描述

2.5.2Sting

  • String类是java.lang 包内的类，java.lang 包内的类不需要手动导入，可直接实例化对象后使用。

  • String类代表字符串。 Java程序中的所有字符串文字（例如"abc" ）都被实现为此类的实例。 字符串不变; 它们的值在创建后不能被更改。

  • 常用构造方法：
    在这里插入图片描述
    将以直接使用直接赋值的方式：String s="abcd"

  • Sting对象的特点：通过new关键字创建的对象，每一次new都会申请一个内存空间，虽然内容相同，但是地址值不同。
    在这里插入图片描述

  • JVM会首先创建一个字符数组，然后每一次new的时候都会有一个新的地址，只不过是s1与s2参考的字符串内容相同。

     char[] chs={'a','b','c'};
     String s1=new String(chs);
     String s2=new String(chs);
  • 以“”方式创建的字符串，只要字符序列相同（顺序和大小写），无论程序中出现几次，JVM只会创建一个String对象，并在字符串池中维护。
      //方法二:放在常量池
        String s3="abc";
        String s4="abc";

在这里插入图片描述

2.5.3字符串的比较equal()

  • 使用==来比较的：基本类型：比较的是数据值；引用类型：比较的是地址值
  • 字符串是对象，他比较内容是否相同，是同过方法来实现：equal()
    将此字符串与指定对象进行比较。 其结果是true当且仅当该参数不是null并且是String对象，表示相同的字符序列作为该对象。
    在这里插入图片描述
package API;

public class String1 {
    public static void main(String[] args) {
        //方法一：构造方法的方式得到对象
        char[] chs={'a','b','c'};
        String s1=new String(chs);
        String s2=new String(chs);

        //方法二：直接赋值的方法得到对象
        String s3="abc";
        String s4="abc";
        //比较字符串对象地址是否相等
        System.out.println(s1==s2);
        System.out.println(s1==s3);
        System.out.println(s3==s4);
        System.out.println("-------------");
        //比较字符串的内容是否相等
        System.out.println(s1.equals(s2));
        System.out.println(s1.equals(s3));
        System.out.println(s3.equals(s4));

    }
}

在这里插入图片描述

2.5.4字符串的遍历

  • 用到的方法：输入字符串方法nextline();
  • 获取单个字符方法：字符串名.charAt(i)//i从0开始遍历,返回char指定索引处的值。 指数范围为0至length() - 1 。 该序列的第一个char值在索引0 ，下一个索引为1 ，依此类推，与数组索引一样。
  • 获取字符串长度：字符串名.length()
  • 方法一：通过方法charAt()
package API;
import java.util.Scanner;
public class Sting遍历 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入字符串：");
        //CTRL+alter+v自动补全
        String line = scanner.nextLine();
        for (int i=0;i<line.length();i++){
            System.out.println(line.charAt(i));//逐个输出字符
        }

    }
}

在这里插入图片描述
方法二：将String对象转化为字符数组char[]

package com.bipt.day06_String;
/*方法一：通过循环和方法charAt(index)遍历得到需要的字符*/
//遍历字符：字符串拥有长度length()与索引，可以遍历
public class Demo01_遍历 {
    public static void main(String[] args) {
        String s="abcdefg";
/*        for (int i = 0; i < s.length(); i++) {
            System.out.println(s.charAt(i));//charAt(index)字符串不是数组，要通过此方法查找元素
        }*/

        //方法二：由于String类型的底层实现是字符数组，可以将String对象转换为字符数组，然后对数组遍历
        /*public char[] toCharArray()将此字符串转换为新的字符数组。
        结果 ：
        一个新分配的字符数组，其长度是该字符串的长度，其内容被初始化为包含由该字符串表示的字符序列。
*/
        char[] array=s.toCharArray();
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

2.5.5StingBuilder

  1. StringBuilder是一个可变的字符串类，我们可以将其看成一个容器，这里可变指的是String Builder对象中内容可变。
  2. 与String的区别：String定义的字符串内容不可变，对字符串进行操作（如拼接）都会创建一个新的对象，既耗时又浪费空间。 StringBuilder定义的字符串内容可变。
  3. 而这种操作还不可避免，因此通过Java提供的StringBuilder类可以解决这个问题。
    在这里插入图片描述
  4. 两个常用构造方法：
package API;
public class String_builder {
    public static void main(String[] args) {
        StringBuilder s1 = new StringBuilder();//构造一个没有字符的字符串构建器，初始容量为16个字符。
        System.out.println("s1内容："+s1);
        System.out.println(s1.length());


        StringBuilder s2 = new StringBuilder("hello");//构造一个初始化为指定字符串内容的字符串构建器。
        System.out.println("s2内容："+s2);
        System.out.println(s2.length());
    }
}

在这里插入图片描述
5. StringBuilder的常用方法：添加append与反转reverse
在这里插入图片描述
需要注意的是：append()方法添加完数据后返回的不是新对象仍然是原来的对象。
在这里插入图片描述

  StringBuilder s1 = new StringBuilder();//构造一个没有字符的字符串构建器，初始容量为16个字符。

        System.out.println(s1.length());
        s1.append(123456);
        System.out.println("s1内容："+s1);
        s1.reverse();
        System.out.println("s1反转后的内容："+s1);

在这里插入图片描述

  //链式编程
        s2.append("world").append(123).append("你好");
        System.out.println(s2);

在这里插入图片描述

2.5.6String 与String Builder之间相互转换

  1. 有时需要创建的String对象，但又想使用StringBuilder中的append()和builder（）方法，只有将String类型转换为StringBuilder 类型，使用完之后再准换回来。
  2. 转换方法：在这里插入图片描述
package API;

public class toString {
    public static void main(String[] args) {
        //1.创建StringBuider对象
        StringBuilder sb1 = new StringBuilder();
        sb1.append("hello world!");
        //转换为String类型
        String sb2=sb1.toString();
        System.out.println(sb2);

        //2.String类型转StringBuilder，要通过构造方法来实现
        String sb3="你好";
        StringBuilder sb4= new StringBuilder(sb3);
        System.out.println(sb3);

    }
}

在这里插入图片描述

2.6接口

- 接口1的定义

  • 由于接口不是类，所以其中定义的方法无法直接实现（且接口中无构造方法）
  • 接口用来定义不同的方法，让不同的人实现（分工）
  • 接口中的方法默认是public abstract类型
  • implement可以实现多个接口
package Demo6;

public interface UserService {
    //接口中的所有定义都是抽象的 public abstract
    void run(String anme);//定义方法可以不用写public abstract，默认就是
    void Delete(String name);
}
//定义完接口后可通过类来实现
  • 接口2的定义
package Demo6;

public interface TimeService {
    void time();
}
  • 两个接口的继承（java是单继承，但接口中可以实现多继承），重写里面的方法即可
package Demo6;
//快捷键alt+insert选中implment
//实现接口的类必须重写接口中的方法
//接口可以多继承
public class UserServiceImp implements UserService,TimeService{
    @Override
    public void run(String anme) {

    }

    @Override
    public void Delete(String name) {

    }

    @Override
    public void time() {
        
    }
}

2.6Java中内部类

  • 内部类定义
package Demo14;

public class Outer {
    private int id=10;
    public void out(){
        System.out.println("这是外部类方法");

    }
    //内部类
    public class Inner{
        public void in(){
            System.out.println("这是内部类方法");
        }
        //内部类方法可以调用外部类中私有属性
        public void getID(){
            System.out.println(id);
        }

    }
}
  • 测试类Application
package Demo14;

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过外部类对象实例化内部类
        Outer.Inner inner = outer.new Inner();
    }
}
  • 一个java文件中只能有一个public类，但是可以有多个class类，所以一些测试类可以写在class A{}中，不用再 建立一个新的java文件。
package Demo14;

public class Outer {
    private int id=10;
    public void out(){
        System.out.println("这是外部类方法");

    }
}
class A{
    
}
class B{
    
}
  • 方法中也可以写类：局部内部类，类似于方法中定义的变量叫做局部变量
package Demo14;

public class Outer {
//局部内部类
    public void out(){
        class A{

        }

    }
}
  • 匿名内部类：不将类的实例保存的变量中，正常实例化及调用类中属性
  • A a=new A();a.name;
package Demo14;

public class Application {
    public static void main(String[] args) {
     new Apple().eat();

    }
}
class Apple{
    public void eat(){
        System.out.println("1");
    }
}

2.7 java中异常机制

泰勒今天想展开
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java面向对象基础实验小结_JAVA面向对象基础小结
weixin_31188325的博客
02-28 1504
JAVA基础知识JAVA的面向对象(obtion object)Java面向对象首先要理清对象和类的关系：1. 类是对象的模板，对象是类的体现；现在把一个类比较一张汽车设计图纸，对象比做刚按照这张图纸制造出来的汽车。2. 一个类有很多对象，对象不能改变类的内容。一张图纸能够造出很多汽车，，其中的一辆车进行了改装，但是没能改变设计图纸，所以后面制造出来的汽车还是没有受到影响。3.创造一个类(类名首字...
JAVA面向对象基础学习资料
07-09
JAVA面向对象的基础学习资料，包括了以下学习内容和代码注释： 01_成员变量和局部变量的区别 02_形式参数是类名的问题 03_匿名对象 04_封装和private关键字 05_this关键字 06_构造方法 07_成员方法 08_创建对象做了...
JavaSE笔记（六）重制版
qq_45420103的博客
06-05 316
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hqvdx4nQ-1685927311485)(https://s2.loli.net/2022/10/04/SkAn9RQpqC4tVW5.png)] 集合类与IO 前面我们已经把基础介绍完了，从这节课开始，我们就正式进入到集合类的讲解中。 集合类 集合类是Java中非常重要的存在，使用频率极高。集合其实与我们数学中的集合是差不多的概念，集合表示一组对象，每一个对象我们都可以称其为元素。不同的集合有着不同的性质，比如一些集合允许
Java基础自学记录七
MXYLL_的博客
09-28 473
Java基础——面向对象编程(中级部分)
Java面向对象基础
weixin_60719453的博客
10-13 8385
一、前言 我们上次学过java的方法，现在我们来学习新的一篇，也算是java中比较重要的一节了 面向对象基础是java中核心。 面向对象主要包括封装、继承、多态 我们这节主要讲的是封装，在这之前我们先来了解一下类和对象的定义和关系 什么是对象？ 世间一切都是对象，万物解释对象，对象就是看得见摸得着的东西。 什么是类？ 类是现实生活中对具有属性和行为同一类的总称。 类和对象的关系？ 类是对象的抽象化，对象是类的实例化 类的定义 ？ 类是java中的基本概念，java中
java基础-面向对象
codeglory的博客
04-21 6202
java基础部分-面向对象的概念，类之间关系，并部分解释了UML类图
Java面向对象浅谈
编程界明世隐的博客
12-06 4922
作者简介 作者名：编程界明世隐 简介：CSDN博客专家，从事软件开发多年，精通Java、JavaScript，博主也是从零开始一步步把学习成长、深知学习和积累的重要性，喜欢跟广大ADC一起打野升级，欢迎您关注，期待与您一起学习、成长、起飞！ 热门专栏推荐 【1】Java小游戏（俄罗斯方块、飞机大战、植物大战僵尸等） 【2】JavaWeb项目实战（图书管理、在线考试、宿舍管理等） 【3】JavaScript精彩实例（飞机大战、贪吃蛇、验证码等） 【4】Java小白入门200例 【5】从零学Java、趣学J
java学习---面向对象基础
MTYSYS19990212的博客
05-07 2597
1、面向对象基础 1.1、 面向对象思想 1.1.1、 概述 面向对象(Object Oriented)是软件开发方法，一种编程范式。面向对象的概念和应用已超越了程序设计和软件开发，扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。面向对象是一种对现实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。 面向对象是相对于面向过程来讲的，面向对象方法，把相关的数据和方法组织为一个整体来看待，从更高的层次来进行系统建模，更贴近事物的自然运行模
JAVA面向对象学习心得
a18786923310的博客
07-25 1826
java面向对象的知识归纳，包括（继承、封装、多态）等面向对象的特性的总结。
《Java面向对象程序设计》学习笔记
weixin_45940369的博客
07-31 8024
备考某学校的 817程序设计Java 专业课，在学习耿祥义老师的《Java面向对象程序设计（第3版）-微课视频版》。 发一些自己的学习笔记到专栏（一篇文章对应书上一章），可能不会及时更新，见谅。 笔记可能有错误，看看就得，现在懒得浓缩精炼了，以后再说吧🧐
基于Java基础-面向对象实现植物大战僵尸简易版
热门推荐
weixin_43776741的博客
03-31 2万+
基于Java基础-面向对象实现植物大战僵尸简易版前言游戏设计游戏对象游戏内容游戏优化放置植物的优化移除植物的优化游戏可玩性的优化添加游戏背景音乐后续优化源码分享 前言 从零开始学习的Java的第一个月，在面向对象(OOP)的学习中，跟着讲师完成了飞机大战的游戏编码。第二个月开始接触API，心血来潮便结合API中的集合、多线程开始植物大战僵尸的编码，从游戏模式的设计到游戏内容的实现大约花费2个礼拜的...
Java开发基础（基础语法+面向对象基础+集合基础+常用API）
01-13
适合想学习Java开发的小白当作学习笔记
java+初识面向对象+基础题目
07-14
在本节中，我们将通过一系列的题目，深入探讨Java面向对象的基础知识。这些题目涵盖了Java中的面向对象编程的基本概念，包括类、对象、继承、多态、封装等。 题目一：Student类 在这个题目中，我们需要定义一个...
Java面向对象编程学习笔记.pdf
12-01
Java面向对象编程学习笔记是Java程序设计语言中面向对象编程（Object-Oriented Programming，OOP）的一份学习笔记。面向对象编程是一种软件设计方法，它强调使用对象和类来模拟现实世界中的实体和系统。 一、类和...
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 468
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 570
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java内存模型
weixin_44267758的博客
07-19 684
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1188
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 1186
JVM-垃圾回收与内存分配
Java基础学习：面向对象与程序设计
学习Java基础设计不仅涉及语言本身，还包括对面向对象编程的理解，以及如何在实际项目中应用这些知识，例如调整Web应用的欢迎页面设置。通过阅读相关书籍和不断实践，开发者可以逐步掌握Java的精髓，并提升编程能力...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

泰勒今天想展开

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值