Java基础面向对象——封装

面向对象基础

面向对象和面向过程的思想对比

  • 面向过程编程(Procedure Oriented Programming)
    是一种以过程为中心的编程思想,实现功能的每一步,都是自己实现的
  • 面向对象编程(Object Oriented Programming)
    是一种以对象为中心的编程思想,通过指挥对象实现具体的功能

类和对象

类是对象的描述
对象是 类的实体

类的定义

类的组成:属性和行为

  • 属性:在代码中通过成员变量来体现(类中方法外的变量)
  • 行为:在代码中通过成员方法来体现(和前面的方法相比去掉static关键字即可)
    public class 类名{
    //成员变量
    变量1的数据类型 变量1;

    //成员方法
    方法1;

    }

public calss Student{
String name;
int age;
public void study(){
System.out.println(“学习”);
}
}

对象的使用

  • 创建对象
    格式:类名 对象名 = new 类名();
    Student s = new Student();
  • 使用对象
  1. 使用成员变量
    格式:对象名。变量名
    s.name
  2. 使用成员方法
    格式:对象名.方法名()
    s.study();

在这里插入图片描述

案例

定义一个手机类,然后定义一个手机测试类,在手机测试类中通过对象完成成员变量和成员方法的使用

public class phone{
	String brand;
	int price;
	public void call(String name){
		System.out.println("给"+name+"打电话");
	}
	public void sendMessage(){
		System.out.println("群发短信");
	}
}

public class TestPhone{
	public static void main(String[] args){
		Phone p = new Phone();
		p.brand = "米";
		p.price = 1999;
		System.out.println(p.brand +"..."+p.price);
		p.call("森");
		p.sendMessage();
	}
}

对象内存图

单个对象内存图

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

两个对象内存图

.class字节码文件不用再加载一次
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

两个引用指向同一对象内存图

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

垃圾回收

当堆内存中,对象或数组产生的地址,通过任何方式都不能被找到后,就会被判定为内存中的“垃圾”。
垃圾会被java垃圾回收器,空闲的时候自动进行清理

成员变量和局部变量

成员变量:类中方法外的变量
局部变量:方法中的变量
在这里插入图片描述

封装

private关键字

权限修饰符,可以用来修饰成员(变量、方法)
特点:只能在本类当中进行访问
在这里插入图片描述

public class Student{
	String name;
	private int age;
	//设置值
	pulic void setAge(int a){
		if(a>=0 && a<=120){
			age = a;
		}else{
			System.out.println("您的年龄不合理");
		}
	}
	//获取值
	pulic int getAge(){
		return age;
	}
	public void show(){
		System.out.println(name+"..."+age);
	}
}

public class TestStudent{
	public static void main(String[] args){
		Student stu = new Student();
		stu,name = "张三";
		stu.setAge(-23);
		stu.show();
	}
}

this关键字

局部变量和成员变量如果重名,Java使用的是就近原则
public class Student{
private int age = 18;
pulic void method(){
int age = 19;
System.out.prinltn(age);
}
}
控制台:19

public class Student{
private int age = 18;
pulic void method(){
int age = 19;
System.out.prinltn(this.age);
}
}
控制台:18

public class Student{
private int age ;
pulic int getAge(){
return age ; //默认为 return this.age;
}
}

this关键字作用:可以调用本类的成员(变量、方法),解决局部变量和成员变量的重名问题
this:代表所在类的对象引用,方法被哪个对象调用,this就代表哪个对象
在这里插入图片描述
在这里插入图片描述

this内存原理

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

封装

  • 面向对象三大特征(封装、继承、多态)
  • 隐藏实现细节,仅对外暴露公共的访问方式
    私有仅仅是封装的一种体现
  • 封装常见的体现:
  1. 将代码抽取到方法中,这是对代码的一种封装
  2. 将属性抽取到类当中,这是对数据的一种封装
  3. 私有成员变量,提供setXxx和getXxx方法
  • 封装的好处:
    提高了代码的安全性
    提高了代码的复用性

构造方法

构建、创造对象的时候,所调用的方法
格式:

  1. 方法名与类名相同,大小写也要一致
  2. 没有返回值类型,连void都没有
  3. 没有具体返回值(不能由return带回结果数据)
    执行时机:
    创建对象的时候调用,每创建一次对象,就会执行一次构造方法
    不能手动调用构造方法
    作用:
    用于给对象的数据(属性)进行初始化

所有Student对象的age,都是18
class Student{
private int age;
public Student(){
age = 18;
}
}

class Student{
private int age;
public Student(int age){
this.age = age;
}
}
Student s1 = new Student(23);
Student s2 = new Student(24);

注意事项

构造方法的创建:
如果没有定义构造方法,系统将给出一个默认的无参数构造方法
如果定义了构造方法,系统将不再提供默认的构造方法
构造方法的重载:
如果自定义了带参构造方法,还要使用无参数构造方法,就必须再写一个无参数构造方法
无论是否使用,都手动书写无参数构造方法和带参数构造方法

/*
		JavaBean类:封装数据
*/
public class Student{
	private String name;
	private int age;
	//无参数构造
	public Student(){}
	//有参数构造
	public Student(String name, int age){
		this.name = name;
		this.age = age;
	}
public void setName(String name){
	this.name = name;
}
public String getName(){
	return name;
}
public void setAge(String age){
	this.age = age;
}
public intgetAge(){
	return age;
}
public void show(){
	System.out.println(name+"..."+age);
}
}

public class TestStudent{
	public static void main(String[] args){
		//无参数构造方法创建对象,通过setXxx方法给成员变量进行赋值
		Student stu1 = new Student();
		stu1.setName("张三");
		stu1.setAge(23);
		stu1.show();
		//通过带参数构造方法,直接给属性进行赋值
		Student stu2 = new Student("李四"24);
		stu2.show();
	}
}

字符串

API

应用程序编程接口(Application Programming Interface)
键盘输入一个字符串

import java.util.Scanner;
public class Demo1Scanner{
/*
	next() : 遇到了空格,就不再录入数据了
			结束标记:空格、tab键
	nextLine() :可以将数据完整的接收过来
			结束标记:回车换行符
	nextInt和nextLine方法配合使用的时候,nextLine方法就没有键盘录入的机会了
	字符串和整数一起录入,建议使用next方法
			
*/
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入:");
		//ctrl + alt + v 快速生成方法的返回值
		String s = sc.nextLine();
		System.out.println(s);
	}
}

String

String类在java.lang包下,所以使用时不用导包
String类代表字符串,java程序中所有字符串文字(如"abc")都被实现为此类的实例,也就是说,java程序中所有的双引号字符串,都是String类的对象
字符串不可变,他们的值在创建后不能被更改
重新赋值只是让这个字符串变量记录了一个新的对象

String常见构造方法

在这里插入图片描述

注意String这个类比较特殊,打印其对象名的时候。不会出现内存地址,而是该对象所记录的真实内容 ( 面向对象-继承,Object类)

创建字符串对象的区别对比

构造方法能创建对象,双引号也能创建字符串对象,有什么区别

注意 ==号作比较

  • 基本数据类型:比较的是具体的值
    int a = 10;
    int b = 20;
    System.out.println(a == b); //false
  • 引用数据类型:比较地址值
    Student s1 = new Student(23);
    Student s2 = s1;
    System.out.println(s1 == s2); //true

以""方式给出的字符串,只要字符序列相同(顺序和大小写),无论在程序代码中出现几次,JVM都只会建立一个String对象,并在字符串常量池中维护
String s1 = “abc”;
String s2 = “abc”;

  • 字符串常量池:当使用双引号创建字符串对象的时候,系统会检查该字符串是否在字符串常量池中存在
    不存在:创建
    存在:不会重新创建,而是直接复用
    字符串常量池在JDK7版本开始从方法区挪到了堆内存
    在这里插入图片描述
    通过new创建的字符串对象,每一次new都会申请一个内存空间,虽然内容相同,但是地址值不同
    char[] chs = {‘a’, ‘b’, ‘c’};
    String s1 = new String(chs);
    String s2 = new String(chs);
    上面的代码中,JVM会首先创建一个字符数组,然后每一次new的时候都会有一个新的地址
    在这里插入图片描述
    在这里插入图片描述
    双引号创建的字符串对象,在字符串常量池中存储,通过构造方法创建的字符串对象,在堆内存中存储
String字符串的特点
  • java程序中所有的双引号字符串,都是String类的对象
  • 字符串不可变,它们的值在创建后不能被更改
  • 虽然String的值是不可变的,但是它们可以被共享(字符串常量池)

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
当字符串之间使用+号串联(拼接)的时候,系统底层会自动创建一个StringBuilder对象,然后再调用其append方法完成拼接,拼接后,再调用其toString方法转换为String类型
在这里插入图片描述
在这里插入图片描述
Java存在常量优化机制,在编译的时候,就会将"a" + “b” + “c"拼接为"abc”

字符串的比较

使用==做比较

  • 基本数据类型:比较的是具体的值
  • 引用数据类型:比较地址值

字符串是对象,比较内容是否相同,通过equals()方法实现

  • public boolean equals(Object anObject):将此字符串与指定对象进行比较。由于我们比较的是字符串对象,所以参数直接传递一个字符串

equalsIgnoreCase() 忽略大小写比较

案例
  1. 用户登录
    已知用户名和密码是,请用程序实现模拟用户登录,总共给三次机会,登录之后,给出相应的提示
import java.util.Scanner;
public calss Test1{
	public static void main(String[] args){
		String username = "admin";
		String password = "123456";
		Scanner sc = new Scanner(System.in);
		for(int i =1;i<=3;i++){
			System.out.println("请输入用户名:");
			String scUsername = sc.nextLine();
			System.out.println("请输入密码:");
			String scPassword = sc.nextLine();
			if(uesername.equals(scUsername)&&password.equals(scPassword)){
				System.out.println("登录成功");
				break;
			}else{
				if(i==3){
					System.out.println("您的登录次数已达到今日上限,请明日再来");
				}else{
					System.out.println("登录失败,您还剩下"+(3-i)+"次机会");
				}
			}
		}
		
	}
}
  1. 遍历字符串
    键盘录入一个字符串,使用程序实现在控制台遍历该字符串
import java.util.Scanner;
public calss Test1{
	public static void main(String[] args){
		
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入:");
		String s = sc.nextLine();
		for(int i =0;i<s.length();i++){
			System.out.println(s.charAt(i));//charAt 返回指定索引处的char值,字符串的索引也是从0开始的
		}
		
	}
}
import java.util.Scanner;
public calss Test1{
	public static void main(String[] args){
		
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入:");
		String s = sc.nextLine();
		char[] chars = s.toCharArray();//将当前字符串拆分为字符数组
		for(int i =0;i<chars.length;i++){
			System.out.println(chars[i]);
		}
		
	}
}
  1. 统计字符次数
    键盘录入一个字符串,统计该字符中大写字母字符,小写字母字符,数字符出现的次数(不考虑其他字符)
import java.util.Scanner;
public calss Test1{
	public static void main(String[] args){
		
		int da = 0int xiao = 0;
		int shu = 0;
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入:");
		String s = sc.nextLine();
		char[] chars = s.toCharArray();
		for(int i =0;i<chars.length;i++){
			if(chars[i]>='A'&&chars[i]<='Z'){
				da++;
			}else if(chars[i]>='a'&&chars[i]<='z'){
				xiao++;
			}else if(chars[i]>='0'&&chars[i]<='9'){
				shu++;
			}
			System.out.println("大写字母符个数:"+da);
			System.out.println("小写字母符个数:"+xiao);
			System.out.println("数字符个数:"+shu);
		}
		
	}
}
  1. 手机号屏蔽
    以字符串的形式从键盘接受一个手机号,将中间四位号码屏蔽
import java.util.Scanner;
public calss Test1{
	public static void main(String[] args){
		
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入:");
		String s = sc.nextLine();
		String hou = s.substring(s.length() - 4);
		String qian = s.substring(0, 3);//[0,3)
		System.out.println(qian+"****"+hou);
		
		}
		
	}
}
  1. 敏感词替换
    键盘录入一个字符串,如果字符串中包含(TMD),则使用***替换
import java.util.Scanner;
public calss Test1{
	public static void main(String[] args){
		
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入:");
		String s = sc.nextLine();
		String ss = s.replace("TMD", "***");
		System.out.println(ss);
		}
		
	}
}
  1. 切割字符串
    以字符串形式从键盘录入学生信息,例如“张三,23”从该字符串中切割出有效数据,封装为Student学生对象
import java.util.Scanner;

public class Student{
	private String name;
	private int age;
	//无参数构造
	public Student(){}
	//有参数构造
	public Student(String name, int age){
		this.name = name;
		this.age = age;
	}
public void setName(String name){
	this.name = name;
}
public String getName(){
	return name;
}
public void setAge(String age){
	this.age = age;
}
public intgetAge(){
	return age;
}
}
public calss Test1{

	
	public static void main(String[] args){
		
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入学生信息:");
		String s = sc.nextLine();
		String[] arr = s.split(",");
		Stufent stu = new Student(arr[0], arr[1]);
		
		System.out.println(stu.getName()+"..."+stu.getAge());
		}
		
	}
}
小结

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

StringBuilder

StringBuilder是一个可变的字符串类,可以把它看成是一个容器
作用:提高字符串的工作效率

StringBuilder构造方法

在这里插入图片描述

StringBuilder常用方法

在这里插入图片描述
链式编程:如果一个方法返回的是对象类型,对象就可以继续向下调用方法

StringBuilder sb = new StringBuilder();
sb.append("red").append("blue").append("green");
StringBuilder提高效率原理图

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

StringBuilder和String的区别
  • string:内容是不可变的
  • StringBuilder:内容是可变的
案例

1.对称字符串
键盘接受一个字符串,程序判断出该字符串是否是对称字符串,并在控制台打印是或不是
对称字符串:123321、111
非对称字符串:123123

import java.util.Scanner
public class Test{
public static void main(String[] args){
	Scanner sc = new Scanner(System.in);
	System.out.println("请输入对称字符串:");
	String s = sc.nextLine();
	StringBuilder sb = new StringBuilder(s);
	sb.reverse();
	if(s.equals(sb.toString())){
		System.out.println("是");
	}else{
		System.out.println("不是");
	}
	
}
}

2.拼接字符串
定义一个方法,把int数组中的数据按照指定的格式拼接成一个字符串返回,调用该方法,并在控制台输出结果。例如,数组为int[] arr = {1,2,3}; ,执行方法后输出结果为:[1,2,3]

public class Test{
public static void main(String[] args){
	int[] arr = {1,2,3};
	String s = arrayToString(arr);
	System.out.println(s);
}
	public static String arrayToString(int[] arr){
		StringBuilder sb = new StringBuilder("[");
		for(int i = 0; i < arr.length; i++){
			if(i == arr.length - 1){
				sb.append(arr[i]).append("]");
			}else{
				sb.append(arr[i]).append(", ");
			}
		}
		return sb.toString();
	}
}

集合基础

对象数组

将(张三,23)(李四,24)(王五,25)封装为3个学生对象并存入数组随后遍历数组,将学生信息输出在控制台

import domain.Student;
public class Test {

    public static void main(String[] args) {
        Student[] arr = new Student[3];
        Student stu1 = new Student("张三", 23);
        Student stu2 = new Student("李四", 24);
        Student stu3 = new Student("王五", 25);
        arr[0] = stu1;
        arr[1] = stu2;
        arr[2] = stu3;
        for (int i = 0; i < arr.length; i++) {
            Student temp = arr[i];
            System.out.println(temp.getName() + "..." + temp.getAge());
        }
    }
}

package domain;
public class Student {

    private String name;

    private int age;

    public Student() {
    }

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

    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;
    }
}


集合和数组的特点对比

  • 集合类的特点:提供一种存储空间可变的存储模型,存储的数据容量可以发生改变
  • 集合和数组的区别:
  1. 共同点:都是存储数据的容器
  2. 不同点:数组的容量是固定的,集合的容量是可变的
    如果存储的数据,长度经常发生改变,推荐使用集合

ArrayList集合

构造方法和添加方法

在这里插入图片描述

ArrayList <E>
  • 可调整大小的数组实现
  • <E> 是一种特殊的数据类型,泛型
    在出现E的地方我们使用引用数据类型替换即可,如ArrayList< String>,ArrayList<Student>
ArrayList集合常用方法

在这里插入图片描述

案例
  1. 存储字符串并遍历
    创建一个存储字符串的集合,存储3个字符串元素,使用程序实现在控制台遍历该集合
import java.util.ArrayList;

public class Test {

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("zhangsan");
        list.add("lisi");
        list.add("wangwu");
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            System.out.println(s);
        }
    }
}

  1. 存储学生对象并遍历
    创建一个存储学生对象的集合,存储3个学生对象,使用程序实现在控制台遍历该集合
import domain.Student;

import java.util.ArrayList;

public class Test {

    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();
        Student stu1 = new Student("张三", 23);
        Student stu2 = new Student("李四", 24);
        Student stu3 = new Student("王五", 25);
        list.add(stu1);
        list.add(stu2);
        list.add(stu3);
        for (int i = 0; i < list.size(); i++) {
            Student stu = list.get(i);
            System.out.println(stu.getName() + "..." + stu.getAge());
        }
    }
}
package domain;

public class Student {

    private String name;

    private int age;

    public Student() {
    }

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

    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;
    }
}


学生信息从键盘录入

import domain.Student;

import java.util.ArrayList;
import java.util.Scanner;

public class Test {

    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();
        Student stu1 = getStudent();
        Student stu2 = getStudent();
        Student stu3 = getStudent();
        list.add(stu1);
        list.add(stu2);
        list.add(stu3);
        for (int i = 0; i < list.size(); i++) {
            Student stu = list.get(i);
            System.out.println(stu.getName() + "..." + stu.getAge());
        }
    }

    private static Student getStudent() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入学生姓名:");
        String name = sc.next();
        System.out.println("请输入学生年龄:");
        int age = sc.nextInt();
        Student stu = new Student(name, age);
        return stu;
    }
}

  1. 集合删除元素
    创建一个存储String的集合,内部存储(test,张三,李四,test,test)字符串删除所有的test字符串,删除后,将集合剩余元素打印在控制台
    根据元素进行删除,只能删除集合中的第一个元素
import java.util.ArrayList;

public class Test {

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("test");
        list.add("张三");
        list.add("李四");
        list.add("test");
        list.add("test");
        for (int i = 0; i < list.size(); i++) {
            //常量在前,避免空指针调用方法
            if ("test".equals(list.get(i))) {
                list.remove(i);
                //删除后元素递进,需索引-1才能回置
                i--;
            }
        }
        System.out.println(list);
    }
}

在这里插入图片描述
在这里插入图片描述
4. 集合元素筛选
定义一个方法,方法接收一个集合对象(泛型为Student),方法内部将年龄低于18的学生对象找出并存入新集合对象,方法返回新集合。

import domain.Student;

import java.util.ArrayList;

public class Test {

    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();
        Student stu1 = new Student("张三", 10);
        Student stu2 = new Student("李四", 10);
        Student stu3 = new Student("王五", 20);
        list.add(stu1);
        list.add(stu2);
        list.add(stu3);
        ArrayList<Student> newList = getList(list);
        for (int i = 0; i < newList.size(); i++) {
            Student stu = newList.get(i);
            System.out.println(stu.getName() + "..." + stu.getAge());
        }
    }

    public static ArrayList<Student> getList(ArrayList<Student> list){
        ArrayList<Student> newList = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            Student stu = list.get(i);
            int age = stu.getAge();
            if(age < 18) {
                newList.add(stu);
            }
        }
        return newList;
    }
}

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值