面向对象基础语法2-3

最新推荐文章于 2022-08-12 23:54:45 发布
最新推荐文章于 2022-08-12 23:54:45 发布
阅读量110 收藏
点赞数
分类专栏： 学习笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43676248/article/details/117376002
版权

面向对象基础语法2

回调机制

回调机制1
package com.ice.回调机制;

public class SuperCalculator {
	public void add(int a,int b,Myself myself){
		int result=a+b;
		
		//I will call back
		myself.getResult(a, b, result);
	}
}
class Myself{
	
	//if you call me
	public void useSuperCalculator(int a,int b){
		new SuperCalculator().add(a, b, this);
	}
	public void getResult(int a,int b,int result){
		System.out.println("使用回调计算器的结果:"+result);
	}
}
class Test{
	public static void main(String[] args) {
		new Myself().useSuperCalculator(218, 342);
	}
}
回调机制2
package com.ice.回调机制2;

public interface DoWork {
	void getResult(int a,int b,int result);
}
class SuperCalculator{
	//回调MySelf中的方法
	public void add(int a,int b,DoWork doWork){//参数为接口类型，那么回调方法时由实现类对象来决定
		int result = a+b;
		doWork.getResult(a, b, result);
	}
}
class MySelf implements DoWork{
	//去调用SuperCalculator中的方法
	public void useSuperCalculator(int a,int b){
		new SuperCalculator().add(a, b, this);
	}

	@Override
	public void getResult(int a, int b, int result) {
		System.out.println("使用回调机制的结果:"+result);
	}
}
class Test{
	public static void main(String[] args) {
		new MySelf().useSuperCalculator(33, 23);
	}
}

面向对象基础语法3

static

static修饰的方法或代码块中不能使用this与super关键字，static不能修饰构造器

static修饰的方法或变量可以直接使用“类名.”调用（标准）,“对象.”（非标准）。

被static修饰的变量，方法或代码块在相应类中具有全局性。static只能在类中使用。

static修饰代码块，用于初始化静态变量，先于构造器执行，创建对象的次数决定了构造器的执行次数，也决定了非静态代码块的执行次数，但不影响静态代码块的执行次数，创不创建对象，静态代码块都只被执行一次。

单例设计模式

在一个项目中，把一个类的对象设计成只能被创建一次，任何时候，任何地方也使用该类的对象时，实际上使用到的都是该类的同一个对象。

懒汉式
package cn.iceson.singleton;

public class SingleTon {
	protected double d=Math.random();//生成0~1之间的随机一个浮点数
	
	private static SingleTon singleTon=null;
	
	//私有化构造器，不让其他类创建本类的对象
	private SingleTon(){
		
	}
	
	//静态工厂:专门用来生成类的实例
	public static SingleTon singleTon2(){
		if(singleTon==null){
			singleTon=new SingleTon();
		}
		
		return singleTon;
	}
}
测试类
package cn.iceson.singleton;

public class Test {
	public static void main(String[] args) {
		SingleTon singleTon = SingleTon.singleTon2();

		System.out.println(singleTon.d);

		SingleTon singleTon2 = SingleTon.singleTon2();

		System.out.println(singleTon2.d);
	}
}

/*
 其中一次的执行结果为：
 0.7041090609815749
 0.7041090609815749
*/
饿汉式
package cn.iceson.singleton;

public class SingleTon {
	protected double d=Math.random();//生成0~1之间的随机一个浮点数
	
	private static SingleTon singleTon=new SingleTon();
	
	//私有化构造器，不让其他类创建本类的对象
	private SingleTon(){
		
	}
	
	//静态工厂:专门用来生成类的实例
	public static SingleTon singleTon2(){
		return singleTon;
	}
}
测试类
package cn.iceson.singleton;

public class Test {
	public static void main(String[] args) {
		SingleTon singleTon = SingleTon.singleTon2();

		System.out.println(singleTon.d);

		SingleTon singleTon2 = SingleTon.singleTon2();

		System.out.println(singleTon2.d);
	}
}

/*
 其中一次的执行结果为：
 0.7041090609815749
 0.7041090609815749
*/

内部类

两个接口，每个接口中都有一个方法，这两个方法的方法名称和方法参数都相同，一个实现类来实现这两个接口，这个时候，实现类只会重写一个方法，另外一个方法就没有了。此时使用内部类可以解决此问题。

在类中或在类的成员方法中创建的类称为内部类。

内部类分为四种：

  1. 成员内部类
  2. 静态内部类
  3. 局部内部类
  4. 匿名内部类

不管是哪种内部类，内部类都可以是普通类或抽象类的子类，也可以是接口的实现内部类。

内部类实现接口
接口1
package cn.iceson;

public interface Inf1 {
	//启动
	void start();
}
接口2
package cn.iceson;

public interface Inf2 {
	// 开始
	void start();
}
实现类
package cn.iceson;

public class OuterClass implements Inf1{
	
	//内部类
	class InnerClass{
		
	}
	
	//内部类实现接口
	class InnerClassInf implements Inf2{

		//开始
		@Override
		public void start() {
			// TODO Auto-generated method stub
			
		}
		
	}

	//启动
	@Override
	public void start() {
		// TODO Auto-generated method stub
		
	}
}
内部类继承抽象类
其他类
package cn.iceson2;

public class Other {

}
抽象类
package cn.iceson2;

public abstract class Abstr {
	public abstract void start();
}
内部类
package cn.iceson2;

public class OuterClass extends Other {
    
    //内部类
	class InnerClass extends Abstr{

		@Override
		public void start() {
			// TODO Auto-generated method stub
			
		}
		
	}
}
类中的成员
package cn.iceson3;

public abstract class OuterClass {
	
	int a;//普通成员变量
	static int b;//静态成员变量
	static final int C=10;//常量
	
	{
		//初始化块
	}
	
	static{
		//静态初始化块
	}
	
	public OuterClass(){
		//构造器
	}
	
	public void f1(){
		//普通成员方法
	}
	public static void f2(){
		//静态方法
	}
	
	public abstract void f3();//抽象方法
	
	class InnerClass{
		//内部类
	}
}
成员内部类

成员内部类创建在类中、方法外，可以使用四个访问权限修饰符修饰。

成员内部类中不可以有静态成员。

外部类可以使用成员内部类。

成员内部类的实例方法中拥有有外部类对象，使用"外部类名.this"获取，所以可以使用"外部类名.this"访问外部类

成员（内部类的实例方法中 this表示内部类对象，外部类名.this表示外部类对象);

package cn.iceson4;

public class OuterClass {
	int a=10;//成员变量
	static int b=20;//静态变量
	
	/**
	 * 在外部类中访问成员内部类
	 * @author lucky_ice
	 *
	 */
	//成员方法
	public void fun(){
		System.out.println(new InnerClass().x);
	}
	
	class InnerClass{
		int x=100;
//		static int y=200;//成员内部类中不能存在静态成员
		
		/**
		 * 在内部类中访问外部成员：类名.this.成员名
		 * 在内部类中的this表示当前的内部类对象
		 */
		public void fun(){
			System.out.println(OuterClass.this.a);
			System.out.println(OuterClass.b);
			System.out.println(this.x);
		}				
	}	
}
静态内部类

静态内部类创建在类中，方法外，使用static修饰；

四种访问权限修饰符都可以修饰静态内部类，类可以被任何地方使用，其它类使用静态内部类时，要受静态内部类

的权限修饰符影响，这种影响与类中成员变量或成员方法一样；

导入静态内部类的包的格式为import …外部类.静态内部类；

只导入静态内部类的外部类也可以使用静态内部类，只是使用时格式为“外部类.内部类.";

静态内部类中可以有静态成员变量与静态成员方法。

静态内部类的实例方法中没有外部类对象，所以不能在静态内部类中使用"外部类.this”，即静态内部类只能访问外

部类的静态成员，不能访问外部类的实例成员

局部内部类

方法中定义的内部类

局部内部类与局部变量有很多相似之处

一都不可使用权限修饰符修饰

一作用域范围相同，都是定义地方起到第一个""}"结束

局部内部类拥有外部类对象，即可以使用"外部类名.this"访问外部类成员

局部内部类中可访问外部方法的局部变量，但是该局部变量必须是final修饰的。

package cn.iceson4;

public class OuterClass {
	int a=10;//成员变量
	
	public void fun(){
		int x=20;
		
		class InnerClass{
			private void pub() {
				System.out.println(OuterClass.this.a);//访问成员变量
				System.out.println(x);//jdk1.8之后的局部变量默认加上了final修饰,因此在局部内部类中可以直接访问局部变量
			}
		}
	}
}
匿名内部类
  1. 匿名内部类一定是跟在一个new关键字后面
  2. 匿名内部类可以在外部类成员变量赋值是创建
  3. 匿名内部类可以在方法体中直接创建并使用，并且可以与局部内部类一样可以访问外部方法的final修饰的局部变量
  4. 匿名内部类可以在调用方法传参时创建
  5. 匿名内部类中拥有外部类对象,即可以使用"外部类名.this"访问外部类成员
  6. 开发中经常使用匿名内部类实现回调
package cn.iceson6;

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

package cn.iceson6;

/**
 * 匿名内部类
 * 1.在成员变量赋值时创建
 * 2.在方法内部创建并直接使用
 * 3.在方法参数位置创建
 * @author lucky_ice
 *
 */
public class NoNameClass {
	Animal animal=null;//声明引用变量时使用默认值null
	Animal animal2=new Animal();//声明引用变量时就创建对象
	/**
	 * 1.在成员变量赋值时创建
	 * 声明引用变量并创建匿名内部类对象：new 类名(){}
	 */
	Animal animal3=new Animal(){
		@Override
		public void eat(){
			System.out.println("匿名内部类方法");
		};
	};
	
	/**
	 * 2.在方法内部创建并直接使用
	 */
	public void fun(){
		//匿名内部类---》匿名对象，用完一次就回收
		new Animal(){};
		
		Animal animal=new Animal(){
			@Override
			public void eat(){
				System.out.println("匿名内部类的eat方法");
			}
		};
		animal.eat();
	}
	
	/**
	 * 3.在方法参数位置创建
	 */
	public void name(Animal animal) {
		animal.eat();
	}
	public static void main(String[] args) {
		new NoNameClass().name(new Animal(){});//3.在方法参数位置创建
	}
}

package cn.iceson7;

public class Animal {
	public void sleep(){
		System.out.println("Animal sleep...");
	}
}

package cn.iceson7;

public interface Mouse {
	public void click();
}

package cn.iceson7;

public abstract class Computer {
	public abstract void play();
}


package cn.iceson7;

public class NoNameClass {
	public void fun(){
		//普通类实现匿名内部类
		Animal animal=new Animal(){
			@Override
			public void sleep() {
				// TODO Auto-generated method stub
				super.sleep();
				System.out.println("匿名内部类的Animal sleep方法");
			}
		};
		//接口实现匿名内部类,在匿名内部类中必须重写抽象方法
		Mouse mouse=new Mouse() {
			
			@Override
			public void click() {
				System.out.println("Mouse click...");
			}
		};
		
		//抽象类实现匿名内部类,在匿名内部类中必须重写抽象方法
		Computer computer=new Computer() {
			@Override
			public void play() {
				System.out.println("Computer play...");
			}
		};
	}
}
使用匿名内部类作为参数传递
package cn.iceson8;

public class Animal {
	public void sleep(){
		System.out.println("Animal sleep...");
	}
}
class Dog extends Animal{
	@Override
	public void sleep() {
		// TODO Auto-generated method stub
		super.sleep();
		System.out.println("Animal sleep...1");
	}
}

package cn.iceson8;

public abstract class Computer {
	public abstract void play();
}

class MyComputer extends Computer{

	@Override
	public void play() {
		// TODO Auto-generated method stub
		System.out.println("MyComputer play...1");
	}
	
}

package cn.iceson8;

public interface Mouse {
	public void click();
}

class Lenovo implements Mouse{

	@Override
	public void click() {
		// TODO Auto-generated method stub
		System.out.println("Lenovo click...1");
	}
	
}

package cn.iceson8;

public class NoNameClass {
	
	//普通类作为参数时:可以传递普通类对象、子类对象、匿名内部类
	public void m1(Animal a){
		a.sleep();
	}
	//抽象类作为参数时:可以传递子类对象、匿名内部类
	public void m2(Computer c){
		c.play();
	}
	//接口作为参数时:可以传递实现类对象、匿名内部类
	public void m3(Mouse m){
		m.click();
	}
}

package cn.iceson8;

public class Test {
	public static void main(String[] args) {
		NoNameClass nameClass=new NoNameClass();
		/*nameClass.m1(new Animal());//普通类的匿名对象
		nameClass.m1(new Dog());//向上转型，子类对象
		nameClass.m1(new Animal(){//匿名内部类对象
			@Override
			public void sleep() {
				// TODO Auto-generated method stub
				super.sleep();
				System.out.println("Animal sleep...2");
			}
		});
		nameClass.m1(new Dog(){
			@Override
			public void sleep() {
				// TODO Auto-generated method stub
				super.sleep();
				System.out.println("Animal sleep...3");
			}
		});*/
		
		/*nameClass.m2(new MyComputer());
		nameClass.m2(new Computer() {
			
			@Override
			public void play() {
				// TODO Auto-generated method stub
				System.out.println("Computer play...2");
			}
		});
		nameClass.m2(new MyComputer(){
			@Override
			public void play() {
				// TODO Auto-generated method stub
				super.play();
				System.out.println("MyComputer play...3");
			}
		});
		*/
		nameClass.m3(new Lenovo());//向上转型
		
		nameClass.m3(new Mouse() {
			
			@Override
			public void click() {
				// TODO Auto-generated method stub
				System.out.println("Mouse click...2");
			}
		});
	}
}
修饰符适用范围
修饰符名称|范围类属性方法构造器初始化块内部类
publicYYYYY
protectedYYYY
defaultYYYYYY
privateYYYY
finalYYYY
abstractYYY
staticYYYY
心灵笔记
关注
专栏目录
c#面向对象控制台-通讯录数组添加联系人
12-31
2. **面向对象编程（OOP）**： - OOP的核心概念包括类（Class）、对象（Object）、继承（Inheritance）、封装（Encapsulation）和多态（Polymorphism）。在本例中，我们可能需要创建一个`Contact`类来表示联系人，...
educoder头歌 | Java控制语句
X_YMY的博客
10-14 1622
在本关中，给定a和n的值，要求计算得到sum的值。在本关中，你将被要求对命令行输入某年某月某日（多个数字用空格隔开），判断这一天是这一年的第几天，输出结果。现在在外国留学的小明刚刚得到了他的一门课的成绩，请你写一个小程序告诉他这门课的绩点是多少。在本关中，你将被要求接收命令行输入的一个正整数n，利用for循环求其阶乘，即n!例如当a=2，n=3时，2+22+222=246，即sum的值为246。在外国的高校中，学生的成绩都是通过绩点来表示，那么绩点是怎么计算的呢？60~70分：2.5绩点。
java课后作业
weixin_43873355的博客
11-13 477
1.this和super各有几种用法？ 1.子类的构造函数如果要引用super的话，必须把super放在函数的首位。 2.子类中的同名成员变量或方法隐藏了父类的成员变量或方法，需要用到super。 3.用super直接传递参数。 2.子类对象实例化的具体过程是什么？ 1.子类在构造对象时候，必须访问父类的构造函数，为了完成这个必须的动作，就在子类的构造函数中加入了super()语句。 2.如果父类...
java单元测试实例_JUnit基础及第一个单元测试实例（JUnit3.8）
weixin_39939303的博客
02-12 525
JUnit基础及第一个单元测试实例(JUnit3.8)单元测试单元测试(unit testing) ，是指对软件中的最小可测试单元进行检查和验证。单元测试不是为了证明您是对的，而是为了证明您没有错误。单元测试主要是用来判断程序的执行结果与自己期望的结果是否一致。关键是在于所用的测试用例(Test Case) 。JUnitJUnit是一个Java语言的单元测试框架。Java的很多IDE，比如Ecli...
Lambda表达式
自定义的Vae
12-15 352
文章目录Lambda函数式编程思想Lambda表达式使用前提Lambda表达式省略格式Lambda表达式的应用Lambda表达式无参数无返回值Lambda表达式有参数有返回值Lambda表达式有参数无返回值 Lambda函数式编程思想 语法格式 (参数列表) -> {方法体} Lambda表达式是一个匿名函数，基于数学中的λ演算得名 面向对象过程强调的是通过对象的形式来做事情，调用对象的方法来完成事情 而函数式编程思想强调的是做什么，而不是以什么形式做，只看结果，不看过程 Lambda表达式使用前提
JAVA面向对象编程题
大鱼的翅膀
03-26 1万+
1.给我一个字符串，例如I love java,输出： java love I public class StringReverse { public void swap(char[] arr, int begin, int end) { while(begin < end) { char temp = arr[b...
java基础教程----精华版
09-22
Java是一种广泛使用的面向对象的编程语言，以其平台独立性、安全性、健壮性和高性能而闻名。这个"java基础教程----精华版"显然是一份精心整理的资料，旨在帮助初学者快速掌握Java编程的基础知识。下面将详细介绍Java...
面向对象课程设计报告---学生成绩管理系统.docx
最新发布
11-05
【面向对象课程设计报告---学生成绩管理...通过本次面向对象课程设计，学生不仅能够巩固C++编程基础，还能掌握面向对象编程思想，提升解决实际问题的能力。同时，良好的编程规范和文档编写也是提升软件质量的重要环节。
Java开发基础（基础语法+面向对象基础+集合基础+常用API）
01-13
本文将围绕Java的基础语法、面向对象基础、集合基础及常用API进行详细介绍，特别适合初学者作为学习指南。 #### 二、开发Java的流程 开发Java程序的基本步骤包括编写程序、编译程序和运行程序： 1. **编写程序**...
习题解答-Java面向对象程序设计-邢国波-清华大学出版社.pdf
07-06
5. **基础语法**： - **Scanner类**：用于从标准输入读取数据，如键盘输入。 - **循环控制**：for和while循环是Java中的两种主要循环结构。 - **条件语句**：if和else用于执行基于特定条件的代码。 6. **面向...
多态的案例--计算器类
sang_12345的博客
03-03 231
#include<iostream> using namespace std; #include<string> //分别利用普通写法和多态技术实现计算器 //普通写法 class Calculator { public: double getresult(string oper) { if (oper == "+") { return a + b; } else if (oper == "-") { return a - b; } el.
JAVA面向对象第一章课后作业
tb19930719的博客
04-19 2333
   JAVA面向对象程序设计  第一章课后作业0.计算机package tz1;public class Calculator { int dig1; int dig2; double dig3;    String alg;    public void show() {     System.out.println(dig3);    }   }package tz1;import java...
Java 2 实用教程（第五版）课后习题-【编程题答案】
热门推荐
Z2Min_
07-29 1万+
第二章 1.编写一个应用程序，给出汉字“你” “我” “他” 在Unicode表中的位置。 /* * 要观察一个字符在Unicode表中的顺序位置，可以使用int型类型转换 */ public class Test { public static void main(String[] args) { System.out.println((int)'你'); System...
【Java javac】使用javac命令编译两个不同包目录下的相关java文件
汪汪杂记
08-14 1188
Calculator.java文件 package junit; public class Calculator { public int add(int a, int b) { return a - b; } public int sub(int a, int b) { return a - b; } } CalculatorTest.java文件 package test; import junit.Calculator; imp
Flutter下载图片和视频
qq_43676248的博客
04-25 1708
AndroidManifest.xml <!--用于访问网络，网络定位需要上网--> <uses-permission android:name="android.permission.INTERNET"/> <!--用于写入缓存数据到扩展存储卡--> <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/> <!--文件读取-
MySql基本操作
qq_43676248的博客
06-15 1213
1.数据库的介绍 1.数据库的优点 –存储数据也是存储到磁盘上 –结构化查询 2.数据库中的相关名词 DB:database–数据库：用来保存数据 DBMS:database management system–数据库管理系统：用来创建和管理数据库 SQL:structure query language–结构化查询语言：用来操作数据库中的数据 3.数据库如何保存数据 1.表用来保存数据，每个数据库可以有多张表 2.表中的每一列称为字段，类似于java中的属性 3.表中每一列的字段值构成了表中的一行，类似于
flutter_blue解决分包问题
qq_43676248的博客
04-09 852
flutter_blue 发送包长度大于20时 解决分包问题
flutter 倒计时组件
qq_43676248的博客
08-12 818
代码】flutter 倒计时组件。
Linux的快速使用_jdk安装_tomcat安装_mysql安装-尚学堂~百战程序员学习笔记
qq_43676248的博客
08-15 701
一.Linux 简介 1.发展历史 丹尼斯·里奇 肯·汤普逊 系统内核汇编. B 语言. C 语言做为内核语言,发明 unix linus 召集 unix 原班人马.发明了系统 linus 后更名为 linux 2.所谓的 linux 都是统称,具体版本都叫做发行版. 3.著名的发行版 3.1 red hat : 目前全球最大的 linux 发行厂商.(收费) 3.2 ubuntu:免费版本.界面比较好 3.3 麒麟. 3.5 Cent OS:免费.由 red hat 分支. 4.定位 4.1 操作系统.
Objective-C入门：面向对象编程基础
"Objective-C编程入门教程 - 面向对象编程1" Objective-C是一种面向对象的编程语言，它由Brad Cox在20世纪80年代初设计，旨在扩展C语言的功能，引入了Smalltalk风格的消息传递机制。Dennis Ritchie在早些时候设计的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值