Java面向对象基础-优快云博客

本文链接：https://blog.youkuaiyun.com/Kong_bai_r/article/details/110293529

类的封装

将对象的属性和行为封装起来的载体就是类，类通常对客户隐藏其实现细节，这就是封装的思想

类的继承

//child extends parents
//这里child这个类作为子类继承了parents这个类，并继承parents中的属性和方法
//Java中的类只支持单继承，即一个子类只能继承自一个父类。
class Computer {
	 String screen="液晶显示屏";
	 void startup(){
		 System.out.println("电脑开机中");
	 }
}
public class Pad extends Computer {
	String battery="5000毫安电池 ";
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Computer pc =new Computer();
		System.out.println("computer的屏幕是"+pc.screen);
		pc.startup();
		Pad ipad=new Pad();
		System.out.println("pad屏幕是："+ipad.screen);
		System.out.println("pad电池是："+ipad.battery);
		ipad.startup();
	}

}

方法的重写

重写就是在子类中将父类的成员方法的名称保留，重新编写成员方法的实现内容，更改成员方法的存储权限，或是修改成员方法的返回值类型。

注：在继承中还有一种特殊的重写方式，子类与父类的成员方法返回值、方法名称、参数类型及个数完全相同，唯一不同的是方法实现内容，这种特殊重写方式被成为重构。

注意：当重写父类方法时，修改方法的修饰权限只能从小的范围到大的范围改变。

class Computer2{
	void showPicture(){
		System.out.println("鼠标单击图片");
	}
}

public class Pad2 extends Computer2 {
	void showPicture(){
		System.out.println("手指点击触摸屏");
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Computer2 pc =new Computer2();
		pc.showPicture();
		Pad2 pad=new Pad2();
		pad.showPicture();//重写父类方法
		Computer2 pc2=new Pad2();//父类声明，子类实现
		pc2.showPicture();//调用父类方法，实现子类重写的逻辑
	}

}

super关键字

如果想在子类的方法中实现父类原有的方法，就需要用到super

//super.property;	//调用父类的属性
//super.method();	//调用父类的方法
//super关键字的使用方法与this关键字类似，this关键字代表本类对象，super关键字代表父类对象
class Computer3{
	String sayHi(){
		return "欢迎使用";
	}
}

public class Pad3 extends Computer3 {
	String sayHi(){
		return super.sayHi()+"平板电脑";
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Computer3 pc=new Computer3();
		System.out.println(pc.sayHi());
		Pad3 ipad=new Pad3();
		System.out.println(ipad.sayHi());
		
	}

}

注意：如果在子类构造方法中使用类似super()的构造方法，其他初始化代码只能写在super()之后，不能写在前面，否则会报错。

所有类的父类——Object类

Object类

是所有类的父类，是Java类层中的最高层类。

class Anything{
    
}
//等价于
class Anything extends Object(){
    
}

注意:Object类中的getClass()、notify()、notifyAll()、wait()等方法都不能被重写，因为这些方法都被定义为final类型。

equals()方法

class V{

}

public class Equal {
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
	String s1="123";
	String s2="123";
	System.out.println(s1.equals(s2));//输出true
	V v1=new V();
	V v2=new V();
	System.out.println(v1.equals(v2));//输出false			
	}
}

注意：在自定义的类中使用equals()方法进行比较时，将返回false，因为equals()方法的默认实现是使用"=="运算符比较两个对象的引用地址，而不是比较对象的内容。

类的多态

方法的重载

public class OverLoadTest {
	public static int add(int a){
		return a;
	}
	public static int add(int a,int b){
		return a+b;
	}
	public static double add(double a,double b){
		return a+b;
	}
	public static int add(int a,double b){
		return (int)(a+b);
	}
	public static int add(double a,int b){
		return (int)(a+b);
	}
	public static int add(int... a){
		int s=0;
		for(int i=0;i<a.length;i++){
			s+=a[i];
		}
		return s;
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(add(1));
		System.out.println(add(1,2));
		System.out.println(add(2.1,3.3));
		System.out.println(add(1,3.3));
		System.out.println(add(1.3,3));
		System.out.println(add(1,2,3,4,5,6,7));
		System.out.println(add(3,5,4));
	}
}

抽象类与抽象方法

//[权限修饰符] abstract class 类名{
//	类体
//}
//使用abstract关键字定义的类成为抽象类，而使用abstract关键字定义的方法称为抽象方法
//抽象方法的定义语法如下
//[权限修饰符] abstract 方法返回值类型 方法名（参数列表）;

抽象方法是直接以分号结尾的，它没有方法体，抽象方法本身没有任何意义，除非它被重写，而承载这个抽象方法的抽象类必须被继承，实际上，抽象类除了被继承之外没有任何意义。

注：构造方法不能定义为抽象方法。

接口

接口是抽象类的延伸，可以将它看作是纯粹的抽象类，接口中的所有方法都没有方法体

//[修饰符] interface 接口名 [extends 父接口名列表]{
//	[public][static][final]常量;
//	[public][abstract]方法;
//}
//修饰符：可选，可选值为public 如果省略则使用默认的访问权限
//接口名：必选参数，接口名必须是合法的Java标识符，要求首字母大写一般
//方法：接口中的方法只有定义没有被实现
//一个类实现一个接口可以使用implements关键字
//public class Parallelogram extends Quadrangle implements drawTest{
//...//
//}
//在接口中定义的任何变量都自动是static和final的，因此，在接口中定义变量时，必须进行初始化，
//而且，实现接口的子类不能对接口中的变量重新赋值