第四章面向对象（一）

最新推荐文章于 2024-09-25 10:59:43 发布

两面包夹代码

最新推荐文章于 2024-09-25 10:59:43 发布

阅读量116

点赞数 1

分类专栏： # java SE 文章标签：抽象类 java 设计模式多态编程语言

本文链接：https://blog.csdn.net/qq_44639974/article/details/104409967

版权

java SE 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

4.1 private关键字

特点：

是一个权限修饰符
用于修饰成员（成员变量和成员函数）
被私有化成员只在本类中有效

用法之一

将成员变量私有化，对外对其进行访问。
提高对数据访问的安全性

class Person{
	private String name;
	private int age;
	//设置name的值
	public void setName(String n){
		name = n;
		return;
	}
	//获取name的值 
	//提供对应的setget方法
	public String getName(){
		return name;
	}
	public void setAge(int a){
		if(a < 0 || a > 150){
			System.out.println("年龄不合法");//异常
		}
		age = a;
	}
	public int getAge(){
		return age;
	}
	public void talk(){
		System.out.println("说话...");
	}
	/*
		修饰符:
				public static
				默认
				private
	*/
}
class PersonDemo{
	public static void main(String[] args){
		Person p = new Person();
		p.setAge(-1);
		int a = p.getAge();
	}
}

4.2 构造函数

作用：

用来给对象初始化

格式：

方法名与类名相同
没有返回值类型，没有void
没有具体返回值

注意：

如果你不提供构造方法，系统会给出默认构造方法
如果你提供了构造方法，系统将不再提供
构造方法也是可以重载的，重载条件与普通方法相同

4.3 this关键字

作用：

代表所在类的对象的引用
函数被那个对象调用，this就代表那个对象

什么时候用this

局部变量与成员变量重名

4.4 static 关键字

作用：

-用于修饰成员（成员变量和成员函数）

修饰后的成员特点：

随着类的加载而加载
优先于对象存在
被所有对象所共享
可以直接被类名调用

注意：

静态函数只能访问静态成员
静态函数中不可以写this，super关键字
主函数是静态的
非静态成员既可以访问非静态成员也可以访问静态成员

class Student{
	String name;//实例变量，成员变量
	int age;
	static String school = "123";//静态变量,类变量
	Student(String name, int age){
		this.name = name;
		this.age = age;
	}
	public static void show(){
		System.out.println(name + "," + age + "岁，毕业于" + school);
	}
}
class StaticDemo{
	public static void main(String[] args){
		Student s1 = new Student("zs",19);
		s1.show();
		Student s2 = new Student("lisi",20);
		s2.show();
		System.out.println(Student.school);//类名.属性
	}
}
/*
Static修饰的方法或成员先于对象存储在静态代码区
被static所修饰的成员函数及成员变量还有一种方法去访问，直接 类名 . 属性/类名. 方法
*/

特点：

static是一个修饰符，用来修饰成员
static修饰的成员被多个对象共享，修饰的数据成为了共享数据
static修饰的成员先于对象存在计算机内存中，随着类的加载而存在
多了一种调用方式，类名 . 属性/类名. 方法
成员变量和静态变量的区别
存储位置不同

成员变量存储在堆内存中（对象的特有数据）
静态变量存在静态代码区（所有对象都可以共享的数据）

调用方式不同

成员变量通过对象.成员来调用
静态成员可以通过对象来调用，也可以通过类名来调用

生命周期不同

成员变量与对象共存亡
静态变量与类共存亡

别名不同

成员变量也叫：实例变量
静态变量也叫：类变量

注意

静态成员只能访问静态成员（因为静态成员被储存在静态代码区，静态成员先存在访问不了后来的对象）非静态的即可以访问静态的也可以访问非静态的
静态方法中不能使用this或者super

4.5 main函数解析

在这里插入图片描述

4.6 单例设计模式

单例模式特点

单例类只有一个实例。
单例类自己创建自己的唯一实例。
单例类给其他对象提供对外公共方法。

怎么样保证对象只有一个呢???

不能让别人new对象（用private修饰）
对外提供一个公共方法，供别人调用来完成创建对象这个操作
在本类中创建一个本类的实例

立即加载/饿汉式模式

class Singleton1{
	private static Singleton1 s = new Singleton1(); 
	private Singleton1(){
	}
	public static Singleton1 getInstance(){
		return s;
	}
}

延迟加载/懒汉式模式

class Singleton2{
	private static Singleton2 s = null; 
	private Singleton1(){
	}
	public static Singleton1 getInstance(){
		if(s == null){
			s = new Singleton2();
		}
		return s;
	}
}

4.7代码块

局部代码块

定义在方法或者语句中

特点：以“{ }”划定的代码区域，

	class Person{
	//构造代码块2
	{
		System.out.println("2构造代码块......");
	}
	//静态代码块1
	static {
		System.out.println("1静态代码块......");
	}
	//构造函数3
	Person(){
		System.out.println("3构造函数......");
	}
	void show(){
		int x = 9;
		//局部代码块4
		{
			System.out.println("4局部代码块......");
		}}}
class BlockDemo{
	public static void main(String[] args){
			Person p = new Person();
			p.show();
			Person p2 = new Person();
			p2.show();
			Person p3 = new Person();
			p3.show();}}

运行结果

静态代码块只会在程序开始时执行一次

4.8 匿名对象

语法：new 类名（）；

匿名对象只能够调用一次

在这里插入图片描述

4.9 final关键字

final特点

可以修饰类，方法，变量。
被final修饰的任何类或方法或变量都不能被修改或覆盖其为最终形态

Final修饰的类不可以被继承。

在这里插入图片描述
Final修饰的方法不可以被覆盖。

Final修饰的变量只是一个常量。只能被赋值一次。

*内部类只能访问被final修饰的局部变量。

final修饰的类不能被继承
final修饰的变量是一个常量，只能被赋值一次
final修饰的方法不能被子类重写

4.10 抽象类

在这里插入图片描述

没有方法体的方法就是：
没有大括号这时候就要加关键字
abstract表明这是一个抽象类

若类中有一个方法被abstract所修饰，那么这个类就要被abstract所修饰

特点:

抽象类无法被实例化（无法构造对象，无法被new）
子类继承抽象类时，要么这个子类也是抽象类，要么子类需要把父类中的所有抽象方法进行重写

问题?

1.抽象类中有构造函数吗？

可以，用于给子类对象进行数据初始化

2.抽象类中可以不定义抽象方法吗?

可以的，但是用的比较少目的就是为了不让你new对象

3.abstract使用的时候有限制吗？

private static final 不能一起使用

3.抽象类一定是一个父类吗？

是的，一定是个父类

4.11 接口概述

在这里插入图片描述

接口特点1：

成员变量：都是被public static final修饰
成员函数：都是被public abstract修饰
接口内成员权限都是公共的只能存在抽象成员

interface A{
	public static final String name = "aa";
	public abstract void eat();
}

接口特点2：

类与接口之间是实现关系，通过implements关键字
子类实现了接口，必须对接口中所有的方法进行重写(覆盖)否则这个子类就是抽象类
接口不能new，不能实例化

class QQ implements A{
	public void eat(){
	}
}
interface B{
}

接口特点3：

子类可以继承一个类的同时，还可以实现多个接口
接口的出现避免了单继承的局限性

class Q extends QQ implements A,B{}

接口特点4：

类与类之间是单继承
接口与接口之间可以多继承
一个类继承一个类实现多个接口

interface C extends A,B{}
class InterfaceDemo1{}

接口的应用

一个简单的小例子

在这里插入图片描述

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

abstract class 运动员 extends Person{
	abstract void 学习();
}
abstract class 教练员 extends Person{
	abstract void 教();
}


interface A{
	void 学英语();
}


class 篮球运动员 extends 运动员 implements A{
	public void 学习(){
		System.out.println("学习扣篮...");
	}
	
	public void 学英语(){
		System.out.println("篮球运动员学习英语....");
	}
}

class 篮球教练员 extends 教练员{
	public void 教(){
		System.out.println("教扣篮...");
	}
}

class Demo{
	public static void main(String[] args){
		篮球运动员 player = new 篮球运动员();
		player.学习();
		player.学英语();
	}
}
/*