第4章 面向对象编程_5_关键字

已于 2022-06-06 10:21:43 修改
阅读量191 收藏
点赞数
分类专栏： Java基础 文章标签： java 语音识别 开发语言
于 2020-06-28 21:29:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46486966/article/details/107008235
版权

文章目录

return

使用范围

方法中

作用
  • 结束方法
  • 针对于有返回值类型的方法，使用“return 数据” 格式，方法可以返回所需要的的数据。
注意
  • return后面不可以声明执行语句。

this

使用范围

​ 修饰或调用属性、方法、构造器。

​ this理解为：当前对象或当前正在创建的对象。

运用
  • 在任意方法或构造器内，如果使用当前类的成员变量或成员方法可以在其前面添加this，增强程序的阅读性。通常习惯省略this。
  • 当形参与成员变量同名时，如果在方法内或构造器内需要使用成员变量，必须添加this来表明该变量是类的成员变量。
  • 使用this访问属性和方法时，如果在本类中未找到，会从父类中查找。
class Person{ 
    private String name ;
    private int age ;
    public Person(String name,int age){
        //形参与成员变量同名
    	this.name = name ; 
   	    this.age = age ;
    }
    public void getInfo(){
    	System.out.println("姓名：" + name) ;
    	this.speak();
    }
    public void speak(){
    	System.out.println(“年龄：” + this.age);
    } 
}
注意
  • 在类的构造器中，可以显式的使用"==this(形参列表)=="方式，调用本类中指定的其他构造器。
  • 构造器中不能通过"this(形参列表)"方式调用自己。
  • 如果一个类中有n个构造器，则最多有n - 1构造器中使用了"this(形参列表)"。
  • 规定："this(形参列表)"必须声明在当前构造器的首行。
  • 构造器内部，最多只能声明一个"this(形参列表)"，用来调用其他的构造器。
class Person{ 
    private String name ;
    private int age ;
    // 无参构造器
    public Person(){ 
   	 System.out.println("新对象实例化") ;
    }
    public Person(String name){
        // 调用本类中的无参构造器
    	this(); 
    	this.name = name ;
    }
    public Person(String name,int age){
        // 调用有一个参数的构造器
    	this(name) ; 
    	this.age = age;
    }
    public String getInfo(){
    	return "姓名：" + name + "，年龄：" + age ;
    } 
}

super

使用范围

修饰或调用父类的属性、方法、构造器。

运用
  • 运用使用在子类的方法或构造器中，可以通过使用"super.属性"或"super.方法"的方式，显式的调用父类中声明的属性或方法。通常情况下，习惯省略"super."
  • 当子类和父类中定义了同名的属性时，必须==显式的使用"super.属性"==的方式，表明调用的是父类中声明的属性。
  • 当子类重写了父类中的方法以后，必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法。
  • 子类中所有的构造器默认都会访问父类中空参数的构造器。
  • 当父类中没有空参数的构造器时，子类的构造器必须通过 this(参数列表) 或者 super(参数列表) 语句显示调用本类或者父类中相应的构造器。同时，只能”二选一”，且必须放在构造器的首行。
  • 如果子类构造器中没有显式调用父类或本类的构造器，父类中又没有无参的构造器，编译出错。
  • 在类中，至少有一个构造器中使用了"super(形参列表)"，调用父类中的构造器。
public class Person {
    private String name;
    private int age;
    private Date birthDate;
    public Person(String name, int age, Date d) {
        this.name = name;
        this.age = age;
        this.birthDate = d; 
    }
    public Person(String name, int age) {
    	this(name, age, null);
    }
    public Person(String name, Date d) {
    	this(name, 30, d);
    }
    public Person(String name) {
    	this(name, 30);
    } 
}

public class Student extends Person {
    private String school;
    public Student(String name, int age, String s) {
        super(name, age);
        school = s; 
    }
    public Student(String name, String s) {
        super(name);
        school = s; 
    }
    // 编译出错: no super(),系统将调用父类无参数的构造器。
    public Student(String s) { 
        school = s; 
    } 
}
this和super区别
区别点thissuper
访问属性访问本类中的属性，如果本类没有此属性则从父类中继续查找直接访问父类中的属性
调用方法访问本类中的方法，如果本类没有此方法则从父类中继续查找直接访问父类中的方法
调用构造器调用本类构造器，必须放在构造器的首行调用父类构造器，必须放在子类构造器的首行

static

实例变量、局部变量、静态变量的区别

使用范围

​ 属性、方法、代码块、内部类。

修饰属性：静态变量（或类变量）
  • 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用
  • 多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。
  • 静态变量的加载要早于对象的创建。
  • 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。
  • 静态属性举例：System.out; Math.PI;
修饰方法：静态方法
  •   随着类的加载而加载，可以通过"类.静态方法"的方式进行调用.

  •   静态方法中==只能调用静态的方法或属性==；非静态方法中既可以调用非静态的方法或属性，也可以调用静态的方法或属性.

  •   在静态的方法内，不能使用this关键字、super关键字.

  • 如何确定一个属性或方法是否用static修饰？

    属性可以被多个对象所共享，不会随着对象的不同而不同。

    类中的常量常常声明为static。

    操作静态属性的方法，通常设置为static的。

    工具类中的方法，习惯上声明为static的。 比如：Math、Arrays、Collections。

final

使用范围

​ 类、变量和方法。

修饰类

  • 该类不能被继承。

    比如：String类、System类、StringBuffer类

修饰方法
  • 该方法不能被重写。
    比如：Object类中getClass()
修饰属性

  • 成为常量，名称大写，只能赋值一次。

  • 可以赋值的位置有：显式初始化、代码块中初始化、构造器中初始化

  • final double MY_PI = 3.14;

  • static final 用来修饰属性：全局常量

abstract 抽象类

使用范围

  • 抽象的，用来修饰类和方法。

  • 超类声明一个方法但不提供实现，该方法的实现由子类提供，这样的方法称为抽象方法。

  • 有一个或更多抽象方法的类称为抽象类。

1.abstract:抽象的

2.abstract可以用来修饰的结构：类、方法

抽象类
  • 抽象类是用来被子类继承的，不能被实例化。
  • 抽象类中一定有构造器，便于子类实例化时调用。
  • 开发中都会提供抽象类的子类，让子类对象实例化，完成相关的操作。
抽象方法

  • 抽象方法只有方法的声明，没有方法体，以分号结束。

  • 包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法。

  • 子类重写父类中所有的抽象方法后，方可实例化。

  • 子类没有重写父类中的所有的抽象方法，则子类也是一个抽象类，需要使用abstract修饰。

注意
  • 不能用abstract修饰变量、代码块、构造器。
  • 不能用abstract修饰私有方法、静态方法、final的方法、final的类。
public class AbstractTest {
	public static void main(String[] args) {
		//一旦Person类抽象了，就不可实例化
//		Person p1 = new Person();
//		p1.eat();	
	}
}

abstract class Creature{
	public abstract void breath();
}

abstract class Person extends Creature{
	String name;
	int age;
	
	public Person(){}
    
	public Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	
	//不是抽象方法：
//	public void eat(){
//		
//	}
	//抽象方法
	public abstract void eat();
	
	public void walk(){
		System.out.println("人走路");
	}
	
}


class Student extends Person{
	
	public Student(String name,int age){
		super(name,age);
	}
	public Student(){
	}
	public void eat(){
		System.out.println("学生多吃有营养的食物");
	}
	@Override
	public void breath() {
		System.out.println("学生应该呼吸新鲜的没有雾霾的空气");
	}
}
多态的应用
  • 模板方法设计模式(TemplateMethod)
    • 抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。
  • 解决的问题
    • 当功能内部一部分实现是确定的，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。
    • 在软件开发中实现一个算法时，整体步骤很固定、通用，这些步骤已经在父类中写好了。但是某些部分易变，易变部分可以抽象出来，供不同子类实现。这就是一种模板模式。
public class TemplateMethodTest {

	public static void main(String[] args) {
		BankTemplateMethod btm = new DrawMoney();
		btm.process();

		BankTemplateMethod btm2 = new ManageMoney();
		btm2.process();
	}
}
abstract class BankTemplateMethod {
	// 具体方法
	public void takeNumber() {
		System.out.println("取号排队");
	}

	public abstract void transact(); // 办理具体的业务 //钩子方法

	public void evaluate() {
		System.out.println("反馈评分");
	}

	// 模板方法，把基本操作组合到一起，子类一般不能重写
	public final void process() {
		this.takeNumber();
		this.transact();// 像个钩子，具体执行时，挂哪个子类，就执行哪个子类的实现代码
		this.evaluate();
	}
}

class DrawMoney extends BankTemplateMethod {
	public void transact() {
		System.out.println("我要取款！！！");
	}
}

class ManageMoney extends BankTemplateMethod {
	public void transact() {
		System.out.println("我要理财！我这里有2000万美元!!");
	}
}

interface 接口

定义

  • 接口(interface)是抽象方法和常量值定义的集合，使用interface来定义。

  • 由于Java不支持多重继承，当必须从几个类中派生出一个子类，继承它们所有的属性和方法时，就需要接口实现多重继承的效果。

  • 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要…则必须能…”的思想。继承是一个"是不是"的关系，而接口实现则是 "能不能"的关系。

  • 接口的本质是契约，标准，规范，就像我们的法律一样。制定好后大家都要遵守。

请添加图片描述

接口的特点
  • 用interface来定义，和抽象类是并列关系。
  • 接口中的所有成员变量，默认由public static final修饰，可以省略。
  • 接口中的所有抽象方法，默认由public abstract修饰，可以省略。
  • 接口中没有构造器，不能被实例化，采用多继承机制。
  •   JDK7及以前：只能定义全局常量和抽象方法。

  •   JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法。
    1. 静态方法：使用 static 关键字修饰。可以通过接口直接调用静态方法，并执行其方法体。
      举例：Collection/Collections或者Path/Paths这样成对的接口和类。
    2. 默认方法：默认方法使用 default 关键字修饰。可以通过实现类对象来调用。
      在已有的接口中提供新方法的同时，还保持了与旧版本代码的兼容性。比如：java 8 API中对Collection、List、Comparator等接口提供了丰富的默认方法。
public class SubClassTest {
	public static void main(String[] args) {
		SubClass s = new SubClass();
		
//		s.method1();         错误
//		SubClass.method1();  错误
		//知识点1：接口中定义的静态方法，只能通过接口来调用。
		CompareA.method1();
		//知识点2：通过实现类的对象，可以调用接口中的默认方法。
		//如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法
		s.method2();
		//知识点3：如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的默认方法，
		//那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法。-->类优先原则
        
		//知识点4：如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，
		//那么在实现类没有重写此方法的情况下，报错。-->接口冲突。
		//这就需要我们必须在实现类中重写此方法
		s.method3();	
	}
}

class SubClass extends SuperClass implements CompareA,CompareB{
	
	public void method2(){
		System.out.println("SubClass：上海");
	}
	
	public void method3(){
		System.out.println("SubClass：深圳");
	}
	
	//知识点5：如何在子类(或实现类)的方法中调用父类、接口中被重写的方法
	public void myMethod(){
		method3();//调用自己定义的重写的方法
		super.method3();//调用的是父类中声明的
		//调用接口中的默认方法
		CompareA.super.method3();
		CompareB.super.method3();
	}
}
使用

  • 接口通过让类去实现(implements)的方式来使用。

  • 定义Java类的语法格式：先写extends，后写implements

    class SubClass extends SuperClass implements InterfaceA,InterfaceB,InterfaceC{ }

  • 一个类可以实现多个接口，接口与接口之间可以多继承。

  • 实现接口的类中必须提供接口中所有方法的具体实现内容，方可实例化。否则，仍为抽象类。

public class InterfaceTest {
	public static void main(String[] args) {
		System.out.println(Flyable.MAX_SPEED);
		System.out.println(Flyable.MIN_SPEED);
//		Flyable.MIN_SPEED = 2;   不可以改变filnal修饰的变量值
		Plane plane = new Plane();
		plane.fly();
	}
}

interface Flyable{
	//全局常量
	public static final int MAX_SPEED = 7900;//第一宇宙速度
	int MIN_SPEED = 1;//省略了public static final
	
	//抽象方法
	public abstract void fly();
	//省略了public abstract
	void stop();
	
	//Interfaces cannot have constructors
//	public Flyable(){
//		
//	}
}

interface Attackable{
	void attack();	
}

class Plane implements Flyable{
	@Override
	public void fly() {
		System.out.println("通过引擎起飞");
	}
	@Override
	public void stop() {
		System.out.println("驾驶员减速停止");
	}
}

class Bullet extends Object implements Flyable,Attackable{
	@Override
	public void attack() {
	}

	@Override
	public void fly() {
	}

	@Override
	public void stop() {
	}
}

package com.atguigu.java1;
/*
 * 接口的使用
 * 1.接口使用上也满足多态性
 * 2.接口，实际上就是定义了一种规范
 * 3.开发中，体会面向接口编程！
 * 
 */
public class USBTest {
	public static void main(String[] args) {
		
		Computer com = new Computer();
		//1.创建了接口的非匿名实现类的非匿名对象
		Flash flash = new Flash();
		com.transferData(flash);
		
		//2. 创建了接口的非匿名实现类的匿名对象
		com.transferData(new Printer());
		
		//3. 创建了接口的匿名实现类的非匿名对象
		USB phone = new USB(){

			@Override
			public void start() {
				System.out.println("手机开始工作");
			}

			@Override
			public void stop() {
				System.out.println("手机结束工作");
			}
			
		};
		com.transferData(phone);
		
		
		//4. 创建了接口的匿名实现类的匿名对象
		
		com.transferData(new USB(){
			@Override
			public void start() {
				System.out.println("mp3开始工作");
			}

			@Override
			public void stop() {
				System.out.println("mp3结束工作");
			}
		});
	}
}

class Computer{
	
	public void transferData(USB usb){//USB usb = new Flash();
		usb.start();
		
		System.out.println("具体传输数据的细节");
		
		usb.stop();
	}
	
	
}

interface USB{
	//常量：定义了长、宽、最大最小的传输速度等
	
	void start();
	
	void stop();
	
}

class Flash implements USB{

	@Override
	public void start() {
		System.out.println("U盘开启工作");
	}

	@Override
	public void stop() {
		System.out.println("U盘结束工作");
	}
	
}

class Printer implements USB{
	@Override
	public void start() {
		System.out.println("打印机开启工作");
	}

	@Override
	public void stop() {
		System.out.println("打印机结束工作");
	}
	
}
接口的应用：代理模式(Proxy)

代理模式就是为其他对象提供一种代理以控制对这个对象的访问。

  • 应用场景：

    • 安全代理：屏蔽对真实角色的直接访问。
    • 远程代理：通过代理类处理远程方法调用（RMI）。
    • 延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象。

  • 分类

    • 静态代理（静态定义代理类）
    • 动态代理（动态生成代理类）
    • JDK自带的动态代理，需要反射等知识

  • 举例

public class StaticProxyTest {

	public static void main(String[] args) {
		Proxy s = new Proxy(new RealStar());
		s.confer();
		s.signContract();
		s.bookTicket();
		s.sing();
		s.collectMoney();
	}
}

interface Star {
	void confer();// 面谈

	void signContract();// 签合同

	void bookTicket();// 订票

	void sing();// 唱歌

	void collectMoney();// 收钱
}
//被代理类
class RealStar implements Star {

	public void confer() {
	}

	public void signContract() {
	}

	public void bookTicket() {
	}

	public void sing() {
		System.out.println("明星：歌唱~~~");
	}

	public void collectMoney() {
	}
}

//代理类
class Proxy implements Star {
	private Star real;

	public Proxy(Star real) {
		this.real = real;
	}

	public void confer() {
		System.out.println("经纪人面谈");
	}

	public void signContract() {
		System.out.println("经纪人签合同");
	}

	public void bookTicket() {
		System.out.println("经纪人订票");
	}

	public void sing() {
		real.sing();
	}

	public void collectMoney() {
		System.out.println("经纪人收钱");
	}
}
接口和抽象类异同
区别抽象类接口
定义包含抽象方法的类主要是抽象方法和全局常量的集合
组成构造方法、抽象方法、普通方法、变量、常量常量、抽象方法、(jdk8.0:默认方法、静态方法)
使用子类继承抽象类(extends)子类实现接口(implements)
关系抽象类可以实现多个接口接口不能继承抽象类，但允许继承多个接口
常见设计模式模板方法简单工厂、工厂方法、代理模式
实际作为一个模板是作为一个标准或是表示一种能力

package

定义
  1. 为了更好的实现项目中类的管理，提供“包”的概念。
  2. 包对应于文件系统的目录，package语句中，用==“.”==来指明包(目录)的层次。
  3. 包通常用小写单词标识。遵循标识符的命名规则，通常使用所在公司域名的倒置：com.atguigu.xxx。
作用
  • 包帮助管理大型软件系统：将功能相近的类划分到同一个包中。比如：MVC的设计模式。
  • 包可以包含类和子包，划分项目层次，便于管理.
  • 解决类命名冲突的问题（同一个包不能命名同名的类，接口；不同的包可以）
  • 控制访问权限。例：某航运软件系统包括：一组域对象、GUI和reports子系统
JDK中主要的包介绍
  • java.lang----包含一些Java语言的核心类，如String、Math、Integer、 System和Thread，提供常用功能
  • java.net----包含执行与网络相关的操作的类和接口。
  • java.io ----包含能提供多种输入/输出功能的类。
  • java.util----包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。
  • java.text----包含了一些java格式化相关的类
  • java.sql----包含了java进行JDBC数据库编程的相关类/接口
  • java.awt----包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。 B/S C/S

import

作用

  • 为使用定义在不同包中的Java类，需用import语句来引入指定包层次下所需要的类或全部类(.*)

  • import语句告诉编译器到哪里去寻找类。

  • 语法格式：import 包名. 类名;

import pack1.pack2.Test;
//import pack1.pack2.*;表示引入pack1.pack2包中的所有结构

public class PackTest{
    public static void main(String args[]){
        Test t = new Test(); //Test类在pack1.pack2包中定义
        t.display();
    } 
}
注意
  1. 在源文件中使用import显式的导入指定包下的类或接口
  2. 声明在包的声明和类的声明之间。
  3. 如果需要导入多个类或接口，并列显式多个import语句即可
  4. 可以使用java.util.*的方式，一次性导入util包下所有的类或接口。
  5. 如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。
  6. 如果在代码中使用不同包下的同名的类。需要使用类的全类名的方式指明调用的是哪个类。
  7. 如果已经导入java.a包下的类，需要使用a包的子包下的类的话，仍然要导入。
    –包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。 B/S C/S

import

作用

  • 为使用定义在不同包中的Java类，需用import语句来引入指定包层次下所需要的类或全部类(.*)

  • import语句告诉编译器到哪里去寻找类。

  • 语法格式：import 包名. 类名;

import pack1.pack2.Test;
//import pack1.pack2.*;表示引入pack1.pack2包中的所有结构

public class PackTest{
    public static void main(String args[]){
        Test t = new Test(); //Test类在pack1.pack2包中定义
        t.display();
    } 
}
注意
  1. 在源文件中使用import显式的导入指定包下的类或接口
  2. 声明在包的声明和类的声明之间。
  3. 如果需要导入多个类或接口，并列显式多个import语句即可
  4. 可以使用java.util.*的方式，一次性导入util包下所有的类或接口。
  5. 如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。
  6. 如果在代码中使用不同包下的同名的类。需要使用类的全类名的方式指明调用的是哪个类。
  7. 如果已经导入java.a包下的类，需要使用a包的子包下的类的话，仍然要导入。
  8. import static组合的使用：调用指定类或接口下的静态的属性或方法
渐入佳境~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第5章-JAVA面向对象编程基础.ppt
11-21
JAVA面向对象编程基础 ...本章内容涵盖了 JAVA 面向对象编程的基础知识，包括定义类、创建类的实例对象、构造函数、访问控制修饰符、静态属性和静态方法等，旨在帮助读者掌握 JAVA 面向对象编程的基础知识和技能。
php5-面向对象初步(第一章).pdf
03-31
面向对象编程(OOP)的核心思想在于通过模拟现实生活中的对象来构建程序。它强调的是实体及其属性与行为之间的关系，而不是单纯的函数调用或数据处理。在面向对象的世界里，“**一切皆对象**”。 - **类**：是一种...
FKJAVA读书笔记--第五章--面向对象（上）
叔叔有糖吃的专栏
03-31 563
1.类是引用数据类型。   2.Static修饰的成员不能访问没有static修饰的成员   3.Field=》成员变量=》包括成员变量和类变量   4.类的构造器看上去没有返回值，其实隐式的返回了该类的一个实例。   5.类不是一种具体的存在，类的实例才是。    6.引用变量更像是C语言中的指针。（java将这个指针封装了起来）   7.如果想希望java垃圾回收机制回
Java基础习题（附答案）
热门推荐
望月思灵
06-14 2万+
1. 以下方法fun的功能是求两参数之积。（return  a*b）     int  fun ( int a,  int b )  {   __________________;       }  2. 以下方法fun的功能是求两参数之积。（return  (float)a*b）     float  fun ( int a,  double b )  {   _____________
子类的构造函数默认调用父类的空参构造函数
深圳克林斯曼
02-27 1379
public class Wolf extends Animal { public Wolf() { super("熊大",2); System.out.println("wolf无参构造器"); } public static void main(String[] args) { new Wolf(); } } class Animal extends Creature{ ...
java中的import关键字
xiaotai1234的博客
07-06 890
java中的import关键字 1.定义 为使用定义在不同包中的Java类，需用import语句来引入指定包层次下所需要的类或全部类(.*)。import语句告诉编译器到哪里去寻找类。 语法格式： import 包名. 类名 应用举例： import pack1.pack2.Test; //import pack1.pack2.*; 表示入 引入pack1.pack2包 包 中 的 所有结构 public class PackTest{ public static void main(String args
第六章 JAVA语言中的面向对象特性.rar_java 面向对象
最新发布
09-19
面向对象编程（Object-Oriented Programming，简称OOP）是Java的核心理念，它基于类和对象的概念，旨在提高代码的可重用性、可维护性和模块化。在本章节，我们将深入探讨Java中的这些关键概念。 首先，类是面向对象...
第二章 面向对象编程
05-21
面向对象编程是软件开发中的一种核心概念，尤其在JavaScript中，它允许我们通过类和对象来组织和处理数据。在本章中，我们将深入探讨JavaScript中的面向对象编程思想及其实践。 1. **JavaScript中的对象编程基础** ...
数据库系统课件：第4章 面向对象编程基础.ppt
06-25
本章主要探讨的是面向对象编程的基础知识，特别是类、结构、方法以及属性和索引器的概念。 4.1 类 类是面向对象编程的基础，它是一个模板或者蓝图，描述了一组具有相似特性和行为的对象。类定义了对象的数据结构...
面向对象的关键字介绍
qq_43537005的博客
12-31 1111
面向对象编程中使用的关键字 this super abstract final static package import this关键字的使用 1.this关键字 this可以理解为：当前对象或者当前正在创建的对象(构造器中使用) 1.1 在类的方法中，我们可以使用"this.属性名"或者"this.方法"的方法，调用类中定义的属性或者方法。 通常情况下，我们都会省略"this."。特殊情况，如果方法的形参和类中定义的属性名相同时，我们必须通过"this.属性名"的方式显式调用类种定义的属性，
面试题：下列代码编译和执行后的结果是
不二的博客
10-09 1778
下列代码编译和执行后的结果是 public class Test { public void myMethod(Object o) { System.out.println("My Object"); } public void myMethod(String s) { System.out.println("My String"); ...
Java基础阅读题
lizhong
12-13 3786
一、程序阅读题：（每小题3分，共81分） 1．写出以下程序的运行结果。  public  class  EqualOrNot  { public static void main(String[] args)  { B  b1=new  B(5); B  b2=new  B(5); System.out.println(b1==b2); System.out.println(b1
面向对象的几个基本关键字（一）
lxh5431的博客
07-11 886
类变量：类变量在类中用static关键字声明，在任意的方法，构造函数和代码块外部类变量在程序启动时被创建，在程序结束时被销毁常量：常量是标记为final关键字的类变量，类变量的特性常量均有，再次列出与类变量的区别。 声明常量时必须赋值，且赋值后不能改变其值。 常量名称一般都需要大写。 类变量被存储在常量存储器中。实例变量：实例变量在类中被声明，在任意方法，构造函数和代码块外部在new一个对象
java中的关键字：this与super 大详解
BitHachi
07-30 395
文章目录1.this1.1. this是什么？1.2 this调用对象中的属性、构造器和方法2.super2.1 super是什么？2.2 super调用父类的属性、构造器、方法3. this与super 比较 1.this 1.1. this是什么？ this是Java中的关键字，它的作用和其词义很接近,这个。 它在方法内部使用，即这个方法所属对象的引用； 它在构造器内部使用，表示该构造器正在初始化的对象。 this 可以调用类的属 性、方法和构造器 什么时候使用this关键字呢？ 当在方法内需要用到调
Java面向对象2
Eden_Dragon的博客
09-08 149
一、继承性 为什么要有继承？ 多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中， 那么多个类无需再定义这些属性和行为，只要继承那个类即可。此处的多个类称为子类(派生类)，单独的这个类称为父类(基类 或超类)。可以理解为:“子类 is a 父类”。 类继承语法规则： class Subclass extends SuperClass{ } 作用： 继承的出现减少了代码冗余，提高了代码的复用性。 继承的出现，更有利于功能的扩展。 继承的出现让类与类之间产...
java中Varargs用法
思考、总结、专注
11-03 1607
1.前言 最近开发时要使用AsyncTask类，其中要重写这么一个方法： protected String doInBackground(String... params) { }12 这里的params便是可变参数（有的地方称为变长参数）。 2.详解 String[]和String…的本质相同（都是字符串数组）。  以下为使用String…的例子： public v
第4章 面向对象编程_2_类的成员
糖果有点甜的博客
06-28 322
文章目录属性 Field定义语法格式分类赋值顺序方法 Method定义语法格式方法的调用注意[方法详解](第4章 面向对象编程_4_方法详解.md)构造器作用语法格式特点分类注意代码块作用分类静态代码块：static修饰的代码块非静态代码块：没有static修饰的代码块注意内部类定义分类成员内部类局部内部类匿名内部类修饰符适用范围 属性 Field 定义 属性是类的静态特征，也叫成员变量。 语法格式 修饰符 数据类型 属性名 = 初始化值 ; 常用权限修饰符：private、缺省、protected、pu
第1章 Java语言概述
糖果有点甜的博客
03-13 269
文章目录一、常用的DOS命令二、Java技术体系平台三、Java语言的特点四、Java两种核心机制五、JVM、JRE和JDK关系六、安装JDK步骤七、JDK安装目录内容八、Hello World.java九、注释 一、常用的DOS命令 d: 进入d盘 dir 列出当前目录下的文件以及文件夹 md xxx 创建xxx目录 cd xxx 或 cd d:\x............
PHP5面向对象编程基础教程
PHP5是PHP语言的一个重要版本，它引入了对面向对象编程（Object-Oriented Programming, OOP）的全面支持，极大地增强了PHP作为Web开发语言的能力。面向对象编程是一种编程范式，旨在通过模拟现实世界中的对象和它们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值