JavaSE---------基础知识点08（面向对象（中）)面向对象

80 阅读 0 评论 53 点赞

我是靠谱客的博主聪慧马里奥，最近开发中收集的这篇文章主要介绍JavaSE---------基础知识点08（面向对象（中）)面向对象，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

面向对象

面向对象
- 一、概念
- 二、类
- 三、对象
- 四、成员属性/成员变量
- 五、成员方法
- 六、构造方法
- 七、private - 私有化
- 八封装
- 九、this - 本对象
- 十、分包
- 十一、static - 静态的
- 十二、类加载机制面试题
- 十三、继承
- 十四、super - 父类
- 十五、重写方法
- 十六、访问修饰符
- 十七、Object
- 十八、final的使用
- 十九、抽象类及抽象方法
- 二十、接口

一、概念

在现实世界生活：

类：抽象的概念，把具有相同特征和操作的事物归为一类

先有实体，再有类的概念

在我们代码的世界里：

类：抽象的概念，把具有相同属性和方法的对象归为一列

编写顺序：先有类，再创建对象

类的作用：类相当于一个模板，刻画出具有相同属性和方法的对象

二、类

类中只有属性和方法
属性也叫做全局变量，属性分为成员变量和静态变量
方法分为成员方法和静态方法

public class 类名{
    //属性也叫做全局变量，分为成员变量和静态变量
    
    //成员变量
    数据类型 变量名;
    
    //静态变量
    static 数据类型 变量名;
    
    //方法分为成员方法和静态方法
    
    //成员方法
    访问修饰符 返回值类型 方法名([参数]){}
    
    //静态方法
    访问修饰符 static 返回值类型 方法名([参数]){}
}

三、对象

创建对象的语法：类名对象名 = new 类名();

new 构造方法; 属于对象，就在堆内存中开辟空间

类名对象名：对象名属于引用，存的是对象在堆内存中的地址

操作对象：

设置成员属性
获取成员属性
调用成员方法

四、成员属性/成员变量

语法结构：数据类型变量名;

编写的位置：类里，方法的外面

成员变量 vs 局部变量

成员变量：类里，方法的外面的变量，并且系统会赋默认值，作用在整个类中

局部变量：方法内的变量，系统不会赋默认值，作用在方法中

五、成员方法

语法结构：访问修饰符返回值类型方法名([参数]){}

编写的位置：类里

成员方法 vs 静态方法

成员方法：属于对象的方法，必须使用对象调用

静态方法：属于类的方法，使用类名调用

六、构造方法

在这里插入图片描述

含义：和new一起是创建对象的功能

特点：

与类名相同的方法
没有返回项

作用：

和new在一起是创建对象
初始化属性

注意：

当类中没有写构造方法时，系统会默认添加无参构造（无参数的构造方法）
构造方法可以重载的

有参构造好处：创建对象时，把数据赋值给该对象
public class Person{
    //注意：这种不是构造方法，是成员方法
    public void Person(){}
}
代码理解：
public class Person {
	
	String name;
	char sex;
	int age;
	
	public Person(){}
	
	public Person(String name,char sex,int age){
		this.name = name;
		this.sex = sex;
		this.age = age;
	}
	
	public void eat() {
		System.out.println(this.name + "吃饭饭");
	}
	
	public void sleep() {
		System.out.println(this.name + "睡觉觉");
	}

}
测试类
public class Test {
	
	public static void main(String[] args) {
		Person p = new Person("榮十一", '男', 22);
		p.eat();
		
	}

}

七、private - 私有化

含义：私有化

作用：

修饰属性：私有化属性，不能让外界使用
修饰方法：私有化方法，不能让外界使用

应用场景：不让外界访问的属性和方法就使用private修饰

代码块理解：
类
public class A {
	
	private String str;
	
	private void method01(){
		this.str = "aaa";
		System.out.println(this.str);
	}
	
	public void method02(){
		this.method01();
	}
}
测试类:
public class Test01 {

	public static void main(String[] args) {
		A a = new A();
		
		a.method02();
	}
}

八封装

步骤：

私有化属性
添加get（获取）/set（设置）方法

好处：

外界不可以直接操作属性，必须通过get、set方法操作，可以在get、set方法中做格外的功能
保护属性安全，让属性不能在外界直接调用
添加get/set方法后，可以在获取方法中（get（））和设置方法中（set（））做额外的功能

代码理解：

类

import java.time.LocalDateTime;

public class User {
	
	private String username;
	private String password;
	private String name;
	private double money;
	
	public User() {
	}

	public User(String username, String password, String name, double money) {
		this.username = username;
		this.password = password;
		this.name = name;
		this.money = money;
	}
	
	//获取本对象的money属性
	public double getMoney(){
		//额外的功能
		System.out.println(LocalDateTime.now() + "获取了money属性：" + money);
		return this.money;
	}

	//设置本对象的money属性
	public void setMoney(double money){
		//额外的功能
		System.out.println(LocalDateTime.now() + "设置了money属性：" + money);
		this.money = money;
	}

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	public String getName() {
		return name;
	}

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

测试类

public class Test01 {
	
	public static void main(String[] args) {
		/**
		 * 知识点：封装 
		 * 需求：模拟银行的用户类
		 *
		 * 总结：编写类的流程
		 * 	1.属性
		 * 	2.私有化属性
		 * 	3.无参、有参构造
		 * 	4.get/set方法
		 */
		
		User user = new User("1445584980", "123123", "千锋彭于晏", 3500);
		
		//不要直接操作属性，因为这个行为只能操作属性值，不能做其他功能
//		user.money = user.money-200;
//		System.out.println(user.money);
		
		//取钱：1.存凭证 2.修改金额
		user.setMoney(user.getMoney()-200);
		System.out.println(user.getMoney());
	}
}

九、this - 本对象

含义：代表本对象，this出现方法里，表示调用该方法的对象

作用：

this.属性：调用本对象的成员变量
this.方法：调用本对象的成员方法
this()：调用本对象的构造方法（在一个构造方法中的第一句调用另外一个构造方法）

代码块的理解

类：

public class Person {

	private String name;
	private char sex;
	private int age;
	
	public Person() {
		//调用本类的构造方法
		this("默认姓名", '男', 18);
	}
	
	public Person(String name, char sex) {
		this.name = name;
		this.sex = sex;
	}

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

	public String getName() {
		return name;
	}

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

	public char getSex() {
		return sex;
	}

	public void setSex(char sex) {
		this.sex = sex;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	
	public void eat(){
		//this.name：调用本对象的成员变量
		System.out.println(this.name + "吃饭饭");
		//利用本对象调用成员方法
		this.sleep();
	}
	
	public void sleep(){
		System.out.println(this.name + "睡觉觉");
	}	
}

测试类：

public class Test01 {
	
	public static void main(String[] args) {
		
		Person p = new Person();
		
		System.out.println(p.getName());
		
		p.eat();
	}

}

十、分包

基本作用：防止了类的重名问题

项目作用：项目中有众多的类，把相同功能的类放在同一个包中，方便管理

工具类：com.dream.util/tool

实体类：com.dream.vo/bean/entity

数据库类：com.dream.dao/mapper

十一、static - 静态的

在这里插入图片描述

作用：
修饰属性

类加载到方法区时，JVM会扫描该类的所有属性
并把静态属性加载到静态区中，静态属性属于类属性，
该类所有的对象都共享该属性
静态属性直到项目结束时才会被回收

注意：静态属性使用类名调用

修饰方法

属于类方法，直接用类名调用

应用场景：工具类
静态代码块
静态代码块是类加载到方法区时才会被调用，该代码块只能初始化静态变量

代码块是创建对象时优先于构造方法调用，该代码块可以初始化成员变量和静态变量

构造方法是创建对象时调用，该方法可以初始化成员变量和静态变量
public class A {
	
	String str1;
	static String str2;
	
	//静态代码块：类加载到方法区时调用
	//可以初始化静态变量
	static{
		str2 = "yyy";//A.str2
		System.out.println("A的静态代码块");
	}
	
	//代码块：创建对象时优先于构造方法调用
	//可以初始化静态变量、成员变量
	{
		str1 = "xxx";//this.str1
		str2 = "yyy";//A.str2
		System.out.println("A的代码块");
	}
	
	//构造方法：创建对象时调用
	//可以初始化静态变量、成员变量
	public A() {
		
		str1 = "xxx";//this.str1
		str2 = "yyy";//A.str2
		System.out.println("A的构造方法");
	}
}
public class Test01 {
	
	public static void main(String[] args) {
		/**
		 * 知识点：静态代码块 - 了解
		 */
		
		A a1 = new A();
		A a2 = new A();
		
		
	}

}
静态变量的生命周期：

字节码文件加载到方法区时，系统会扫描该类所有的属性，并把静态变量存放到静态区项目结束时，静态变量才会被回收
成员变量 vs 静态变量

成员变量：属于对象的变量，每个对象独享一份

静态变量：属于类的变量，每个对象都共享一份

代码块的理解：
类：
public class A {
	//成员变量
	String str1;
	//静态变量
	static String str2;
	
}
测试类：
public class Test01 {
	public static void main(String[] args) {
		A a1=new A();
		A a2=new A();
		a1.str1="aaa";
		a2.str1="bbb";
		System.out.println(a1.str1);
		System.out.println(a2.str1);
		A.str2="ccc";
		A.str2="ddd";
		System.out.println(a1.str2);
		System.out.println(a2.str2);
	}
}

十二、类加载机制面试题

一：

public class Test01 {

	public static void main(String[] args) {
		/**
		 * 知识点：类加载机制面试题 
		 */

		System.out.println("A value1:" + A.value1);//1
		System.out.println("A value2:" + A.value2);//0
	}
}

class A{
	
	/**
	 * 准备阶段1：
	 * 	A a;
	 *  int value1;
	 *  int value2;
	 *  
	 * 准备阶段2：
	 * 	A a = null;
	 *  int value1 = 0;
	 *  int value2 = 0;
	 *  
	 * 初始化阶段：
	 * 	A a = new A();
	 *  int value1 = 1;
	 *  int value2 = 0;
	 */
	
	private static A a = new A();
	public static int value1;	
	public static int value2 = 0;

	private A(){
		value1++;
		value2++;
	}

}

二：

public class Test01 {

	public static void main(String[] args) {
		/**
		 * 知识点：类加载机制面试题 
		 */
		System.out.println("B value1:" + B.value1);//1
        System.out.println("B value2:" + B.value2);//1
	}
}

class B{
	
	/**
	 * 准备阶段1：
	 * 	int value1;
	 * 	int value2;
	 * 	B b;
	 * 
	 * 准备阶段2：
	 * 	int value1 = 0;
	 * 	int value2 = 0;
	 * 	B b = null;
	 * 
	 * 初始化阶段：
	 * 	int value1 = 1;
	 * 	int value2 = 1;
	 * 	B b = new B();
	 */
    public static int value1;
    public static int value2 = 0;
    private static B b = new B();

    private B(){
        value1++;
        value2++;
    }
}

十三、继承

使用场景：

多个类似的类，有相同的属性和方法，就可以把相同属性和方法抽取到父类

好处：减少了代码的冗余

public class Person {
	
	String name;
	char sex;
	int age;
	
	public void eat(){
		System.out.println("吃饭饭");
	}
	
	public void sleep(){
		System.out.println("睡觉觉");
	}

}

public class Chinese extends Person{

	String chineseId;
	
	public void playTaiJi(){
		System.out.println("打太极");
	}
}

public class Japanese extends Person{

	String yearNumber;
	
	public void playVideo(){
		System.out.println("拍电影");
	}
}

public static void main(String[] args) {
		/**
		 * 知识点：继承
		 * 含义：子类继承父类的属性和方法
		 * 好处：减少代码冗余
		 * 应用场景：多个类中有相同的属性和方法，就抽取出放在父类里
		 * 
		 * 需求：编写中国人、日本日
		 * 分析：
		 * 	中国人 继承 人类：
		 * 		属性：中国人的身份证
		 * 		方法：打太极
		 * 	日本人 继承 人类：
		 * 		属性：年号
		 * 		方法：拍电影
		 * 	人类：
		 * 		属性：姓名、性别、年龄
		 * 		方法：吃饭饭、睡觉觉
		 */
		
		Chinese c = new Chinese();
		//操作父类属性
		c.name = "榮十一";
		c.sex = '男';
		c.age = 21;
		System.out.println(c.name);
		System.out.println(c.sex);
		System.out.println(c.age);
		//操作子类属性
		c.chineseId = "1234567890";
		System.out.println(c.chineseId);
		//调用父类方法
		c.eat();
		c.sleep();
		//调用子类方法
		c.playTaiJi();
		
		Japanese j = new Japanese();
		//操作父类属性
		j.name = "美田桜奈汾";
		j.sex = '女';
		j.age = 18;
		System.out.println(j.name);
		System.out.println(j.sex);
		System.out.println(j.age);
		//操作子类属性
		j.yearNumber = "令和";
		System.out.println(j.yearNumber);
		//调用父类方法
		j.eat();
		j.sleep();
		//调用子类方法
		j.playVideo();
		
	}
}

深入继承：

创建子类对象，会不会调用父类构造方法？
会
创建子类对象，会不会创建父类对象？
不会
创建子类对象，为什么会调用父类构造方法？
目的是在子类对象中开辟空间用于存放父类的属性

创建子类对象，先调用父类构造方法还是子类构造方法？
先调用子类构造方法

创建子类对象，先完成父类构造方法还是子类构造方法？
先完成父类构造方法

子类可以继承父类私有化的属性和方法吗？

可以继承，但是不可以直接调用，但是可以在父类中设置公有的方法，在公有的方法中调用私有的属性和方法，这叫做间接调用
public class A {
	
	String aAtrr;

	public A() {
		System.out.println("父类的构造方法");
	}
	
	//父类私有化属性
	private String a = "xxx";
	
	//父类私有化方法
	private void aMethod01(){
		System.out.println("父类私有化方法");
	}
	
	public void aMethod02(){
		System.out.println(a);
		aMethod01();
	}
}
public class B extends A{
	
	String bAtrr;

	public B() {
		//super();//调用父类无参构造，默认实现
		System.out.println("子类的构造方法");
	}

}
public class Test01{
	public static void main(String[] args){
		B b = new B();
		
		b.aMethod02();
	
	}
}

十四、super - 父类

含义：代表父类

作用在子类中：

super.属性：调用父类非私有化的成员变量
super.方法：调用父类非私有化的成员方法
super()：调用父类非私有化的构造方法

public class A {

	String str;
	
	public A() {
	}
	
	public void aMethod(){
		System.out.println("A类的方法");
	}
	
}

public class B extends A{
	
	public B() {
		//调用父类的非私有化构造方法
		super();
	}

	public void method(){
		
		//调用父类的非私有化属性
		super.str = "xxx";
		
		//调用父类的非私有化方法
		super.aMethod();
	}
}

十五、重写方法

含义：重写也叫做复写，将父类中方法在子类中重新编写一遍

应用场景：父类方法不满足子类需求时，子类就可以重复父类的方法

条件：

1. 在子类中重写父类的方法
2. 返回值、方法名和参数列表必须和父类重写的方法一致
3. 访问修饰符不能比父类重写的方法更严格

public class Test01 {
	
	public static void main(String[] args) {
		/**
		 * 知识点：重写/复写
		 * 应用场景：父类方法不满足子类需求时，可以在子类中重写
		 * 条件：
		 * 	1.重写的位置是在子类中
		 * 	2.返回值、方法名、参数列表必须和重写父类的方法一致
		 * 	3.访问修饰符不能比父类更严格
		 * 
		 * 需求：编写中国人、日本日
		 * 分析：
		 * 	中国人 继承 人类：
		 * 		属性：中国人的身份证
		 * 		方法：打太极
		 * 	日本人 继承 人类：
		 * 		属性：年号
		 * 		方法：拍电影
		 * 	人类：
		 * 		属性：姓名、性别、年龄
		 * 		方法：吃饭饭、睡觉觉
		 */
		
		Chinese c = new Chinese("榮十一", '男', 21, "1234567890");
		System.out.println(c.getName());
		System.out.println(c.getSex());
		System.out.println(c.getAge());
		System.out.println(c.getChineseId());
		//调用父类方法
		c.sleep();
		//调用子类方法
		c.playTaiJi();
		//调用子类重写父类的方法
		c.eat();
		
		System.out.println("------------");
		
		Japanese j = new Japanese("美田桜奈汾", '女', 18, "令和");
		System.out.println(j.getName());
		System.out.println(j.getSex());
		System.out.println(j.getAge());
		System.out.println(j.getYearNumber());
		//调用父类方法
		j.sleep();
		//调用子类方法
		j.playVideo();
		//调用子类重写父类的方法
		j.eat();
		
	}
}

public class Chinese extends Person{

	private String chineseId;
	
	public Chinese() {
	}

	public Chinese(String name, char sex, int age, String chineseId) {
		super(name, sex, age);
		this.chineseId = chineseId;
	}

	public String getChineseId() {
		return chineseId;
	}

	public void setChineseId(String chineseId) {
		this.chineseId = chineseId;
	}

	public void playTaiJi(){
		System.out.println(super.getName() + "打太极");
	}
	
	@Override
	public void eat(){
		System.out.println(super.getName() + "吃山珍海味");
	}
}

public class Japanese extends Person{

	private String yearNumber;
	
	public Japanese() {
	}
	
	public Japanese(String name, char sex, int age, String yearNumber) {
		super(name, sex, age);
		this.yearNumber = yearNumber;
	}
	
	public String getYearNumber() {
		return yearNumber;
	}

	public void setYearNumber(String yearNumber) {
		this.yearNumber = yearNumber;
	}

	public void playVideo(){
		System.out.println(super.getName() + "拍电影");
	}
	
	//@Override - 注解：既解释给程序员也解释给程序，告诉程序这个方法是重写父类的方法
	@Override
	public void eat() {
		System.out.println(super.getName() + "吃美汾寿司");
	}
}

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

	public String getName() {
		return name;
	}

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

	public char getSex() {
		return sex;
	}

	public void setSex(char sex) {
		this.sex = sex;
	}

	public int getAge() {
		return age;
	}

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

	public void eat(){
		System.out.println(this.name + "吃饭饭");
	}
	
	public void sleep(){
		System.out.println(this.name + "睡觉觉");
	}

}

十六、访问修饰符

含义：修饰类、方法、属性，定义使用的范围

学习：做实验

访问修饰符本类本包其他包子类其他包
private OK
默认的 OK OK
protected OK OK OK
public Ok OK OK Ok

访问修饰符	本类	本包	其他包子类	其他包
private	OK
默认的	OK	OK
protected	OK	OK	OK
public	Ok	OK	OK	Ok

十七、Object

含义：基类也叫做超类，Object是所有类的祖先类

**注意：**如果一个类没有明确继承的父类，默认继承Object

equals：比较两个对象内存地址是否相同

hashCode：获取对象的hash值

getClass：获取类的字节码文件对象

toString：获取对象的字符串表示

标杆作用：

Object作为所有类的父类，定义了几个方法，方便子类去重写

equals的标杆作用：

比较两个对象是否相同，不同的对象比较规则不一样，所以子类重写即可

toString的标杆作用：

每个子类都有不同的属性，重写toString直接打印该对象中所有的属性，方便观察数据

十八、final的使用

含义：最终

作用：

修饰类：该类不能被继承

修饰方法：该方法不能被重写

修饰变量：变成常量，不能重新赋值

常量的命名规则：全大写，单词之间用下划线隔开

常量的声明周期：存在常量池中，直到项目结束才会被销毁

十九、抽象类及抽象方法

//抽象类
public abstract class 类名{
    //抽象方法
    public abstract void method();
}

抽象方法交给非抽象的子类去实现(重写)

应用场景：

当一个方法必须在父类中出现，但是这个方法又不好实现，就把该方法变成抽象方法，交给非抽象的子类去实现

面试题：

抽象类不能有构造方法？

抽象类可以有构造方法

抽象类中只能有抽象方法？

抽象类中有非抽象方法（成员方法和静态方法）

抽象类中不可以没有抽象方法？

抽象类中可以没有抽象方法，但是毫无意义

如果父类是抽象类，则子类必须实现父类的抽象方法？

不一定，子类如果是抽象类，可以不实现父类的抽象方法

可以使用new关键字来创建抽象类对象？

不可以，创建的是匿名内部类的对象

二十、接口

含义：特殊的抽象类

注意：

JDK1.7时，接口中只能有静态常量和抽象方法JDK
1.8开始，接口中有静态常量和抽象方法和默认方法

应用场景：接口更像一个规范

抽象类 vs 接口

抽象类：成员变量、静态变量、静态常量、成员方法、静态方法

接口：静态常量、静态方法、默认方法(JDK1.8)

面试题：

一个类可以实现多个接口？可以

一个接口可以实现多个接口？不可以，接口与接口的关系是多继承

接口里面的方法不一定都是抽象的？JDK1.7时接口里只能有抽象方法，JDK1.8时接口可以有抽象方法和默认方法

接口解决了类的单继承问题？是的，因为类与类是单继承，类与接口是多实现

一个类是否可以继承一个类并同时实现多个接口？可以

接口可以new对象？接口是特殊的抽象类，但是本质还是抽象类，抽象类是不可以new对象的，接口也是不能new对象，new出来的匿名类内部类的对象

类 - 接口的关系：

类 - 类：单继承
类 - 接口：多实现
接口 - 接口：多继承

最后

以上就是聪慧马里奥为你收集整理的JavaSE---------基础知识点08（面向对象（中）)面向对象的全部内容，希望文章能够帮你解决JavaSE---------基础知识点08（面向对象（中）)面向对象所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。

本文分类：JAVA2SE
浏览次数：80 次浏览
发布日期：2023-09-03 06:55:33
本文链接：https://www.kaopuke.com/article/k-p-k_14_uzo_10_fx_12__7__18_3.html

JavaSE---------基础知识点08（面向对象（中）)面向对象

概述

面向对象

一、概念

二、类

三、对象

四、成员属性/成员变量

五、成员方法

六、构造方法

七、private - 私有化

八封装

九、this - 本对象

十、分包

十一、static - 静态的

十二、类加载机制面试题

十三、继承

十四、super - 父类

十五、重写方法

十六、访问修饰符

十七、Object

十八、final的使用

十九、抽象类及抽象方法

二十、接口

最后

评论列表共有 0 条评论

发表评论取消回复

JavaSE---------基础知识点08（面向对象（中）)面向对象

概述

面向对象

一、概念

二、类

三、对象

四、成员属性/成员变量

五、成员方法

六、构造方法

七、private - 私有化

八封装

九、this - 本对象

十、分包

十一、static - 静态的

十二、类加载机制面试题

十三、继承

十四、super - 父类

十五、重写方法

十六、访问修饰符

十七、Object

十八、final的使用

十九、抽象类及抽象方法

二十、接口

最后

相关文章

评论列表共有 0 条评论

发表评论 取消回复

发表评论取消回复