Java OOP

Java OOP

第一章 对象和封装

1. Java 中的命名规则

Java 包名:

​ <1> Java 包名首字母不能小写

​ <2>不能够以[.]开头或结尾

​ <3>组成:由字母和数字组成,只能包含的特殊字符为:_,$,不能以数字开头

Java 类名:

​ <1>首字母大写,帕斯卡命名法

​ <2>必须要和文件名一致

​ <3>组成:由字母和数字组成,只能包含的特殊字符为:_,$,不能以数字开头

​ <4>,每个单词首字母要大写

	区别
Java	属性	方法
C#	字段(属性)	方法

示例:

package ShiLi;

public class Penguin extends Pet {
	private String sex;//性别
	public Penguin(String name,String sex) {
		super(name);
		this.sex=sex;
	}
	public String getSex() {
		return sex;
	}
	/**
	 * 重写父类的print()方法
	 */
	public void Print() {
		super.Print();
		System.out.println("性别是:"+this.sex);
	}
}

2.类的三大特性

​ 封装:就是将具体的实现步骤私有化,提供共有的名字让程序员可以操作

​ 继承:就是子类继承父类

​ 多态:一个事物的多种形态

Java中常见的关键字:

​ final:常量修饰符

​ 1.类似于c#的 constant ,只能够初始话一次值

​ 2.修饰方法: 方法不能够重写了

​ 3.修饰类: 类禁止被继承了

示例:

public class Studne1 {
	//构造函数
	public Studne1() {}
	public Studne1(String name,int age) {
		this.name=name;//----这里就报错了
		this.age=age;
	}
	private final String  name ="";//姓名
	private int age;//年龄
	public void ShowJieShao() {
		if(age>=18) {
			System.out.println("该学员的年龄符合!");
		}else {
			System.out.println("该学员的年龄不符合!");
		}
		System.out.println("我的名字是:"+this.name+"今年的年龄是:"+this.age);
	}

static:静态

1.特点:

​ 静态成员属于类,也可以通过对象名去访问

区别C#:

1. C#中static成员只能够通过类名点

2. Java中的还可以通过对象名,但建议还是使用类名(原因:static成员属于类成员而不是对象成员)

3. 修饰的成员 字段,方法,但是属于类,对象名,但建议还是使用类名

   this.

   当前类的对象引用

   super

   类似于C#base,调用父类成员

   示例:

   package ShiLi;
   
   public class Penguin extends Pet {
   	private String sex;//性别
   	public Penguin(String name,String sex) {
   		super(name);
   		this.sex=sex;
   	}
   	public String getSex() {
   		return sex;
   	}
   	/**
   	 * 重写父类的print()方法
   	 */
   	public void Print() {
   		super.Print();
   		System.out.println("性别是:"+this.sex);
   	}
   }
   

   3.构造函数

   1.作用:用来new对象的,随便给成员变量赋值

   2.语法

   ​ 访问修饰符 类名(形参)<可有可无>{

   }

   3.分类

   根据参数个数

   有参 无参

   根据显示方式

   隐式:无手写构造函数,自己特有一个构造函数

   显式:自己手写了构造函数

   示例:

   public class Bus extends MotoVenicle {
   
   	private int seatCount;//座位数
   	public Bus(String noString,String brand,int seatCount) {
   		super(noString,brand);
   		this.seatCount=seatCount;
   	}
   	public int getSeatCount() {
   		return seatCount;
   	}
   	public void seatCount(int seatCount) {
   		this.seatCount=seatCount;
   	}
   	/**
   	 * 计算价格
   	 */
   	@Override
   	public int calRent(int days) {
   		if(seatCount<=16) {
   			return days*800;
   		}else {
   			return days*1500;
   		}
   	}
   

   重载

   ​ 特点:

   ​ 1.在同一个类中,具有相同的方法名

   ​ 2.有不同的参数,可是个数不一样

   访问修饰符

   public	任何地方都可以访问，本类子类直接访问，其他类 通过对象名
   protected	本类，子类【同包，不同包】可以访问<
   friendly	本类，同包子类可以直接访问只有本类可以访问
   private	只有本类可以访问

第二章 继承

1.含义

​ 子类继承父类

2.语法

访问修饰符 子类类名 extends 父类类名{
    //父类的抽象方法
}

Java 中通过关键字extends来实现,C#中使用 : 特殊符号来实现,修饰符如果是public，则该类整个项目中可见,private只有本类可以使用

在Java中，所有的Java类都直接或间接地继承了。Object类是所有Java类的祖先。在定义一个类时，如果没有使用extends关键字，那么这个类直接继承Object类。

1.继承关系中的重写

子类重写父类的构造函数,先调用父类的构造函数,在使用本类自己的构造函数

方法的重写:

特点: 1.具有相同的方法名

​ 2.重写方法之间的参数列表一致

​ 3.父类的重写方法的访问修饰符必须小于子类的访问修饰符

​ 4.父类重写方法的返回值类型必须大于子类的返回值类型

​ 5.父类重写方法的异常要大于子类的异常

2.super的使用

​ 1.super必须要出现在子类的方法或者构造函数中的第一行

​ 2.可以访问父类的非private的属性,方法,及构造函数

​ 3.super类似于C#的base 用来引用父类的成员

访问修饰符:

访问修饰符	本类	同包	子类(不同包)	不同包
public	√	√	√	√
protected	√	√	√
friendly	√	√
private	√

3.抽象类和抽象方法

特点:

​ 1.通过关键字abstra修饰

​ 2.在抽象类中,可以有抽象方法,也可以有非抽象方法

​ 3.抽象类不能够被示例化,抽象类的抽象方法只能声明,不能够有具体的实现方式

示例:

public abstract class MotoVenicle {
	private String noString;
	private String brand;
	/**
	 * 无参构造方法
	 */
	
	public MotoVenicle() {}
	public MotoVenicle(String noString,String brand) {
		this.noString=noString;
		this.brand=brand;
	}
	public String getNo() {
		return noString;
	}
	public String getBrand() {
		return brand;
	}
	/**
	 * 抽象方法
	 */
	public abstract int calRent(int days);
}

第三章 多态

含义:一个事物的多种形态

1.多态的实现方式

​ 重载:

​ 特点:1.在同一个类中

​ 2.具有相同的方法名,但参数类型不同,或者参数的个数不相同

​ 调用规则:

​ 根据参数类型来调用,或者参数个数来调用

​ 重写:

​ (1)虚方法:

​ 特点;1.在两个拥有继承关系的类中

​ 2.方法名相同,参数类型,参数个数相同,父类的方法使用关键字vital修饰,拥有方法体,子类必须实现父类的虚方法,子类使用override修饰

​ (2)抽象方法:

​ 特点:1.在两个拥有继承关系的类中,父类必须是抽象类

​ 2.方法名相同,参数类型,参数个数相同,父类的方法使 用关键字abstract修饰,只需要声明,不能够拥有方法体,子类必须实现父类的虚方法,子类使用override修饰,除非子类也是抽象方法,不然都要实现虚方法

示例:

public class Aurk extends Father {

	@Override
	public void eat() {
		System.out.println("来自美国的约翰,喜欢吃披萨");

	}

	@Override
	public void Wang() {
		System.out.println("美国的约翰喜欢打橄榄球!");

	}

}

2.向上向下装换

子类到父类的转换（向上转型）

将一个父类的引用指向一个子类对象,自动进行类型转换,此时通过父类引用变量无法调用子类特有的方法

父类到子类的转换（向下转换）

将一个指向子类对象的父类引用赋给一个子类的引用，称为向下转换。此时必须进行强制类型转换。

3.instanceof运算符

作用:

instanceof运算符来进行类型的判断

语法：

对象 instanceof 类或接口

该运算符用来判断一个对象是否属于一个类或者实现了一个接口，结果为true或false。在强制类型转换之前通过instabnceof运算符检查对象的真实类型，再进行相应的强制类型转换，这样就可以避免类型转换异常，从而提高代码的代码量。

示例:

public class Master {
	//构造方法
	public Master() {}

	//调用父类方法
	public void Showdy(Father father) {
		father.eat();//吃
		father.Wang();//玩
	}
	
	//判断客人
	public Father Ker(int i) {
		Father father=null;//父类
		if (i==1) {
			father=new Chinane();
		}if (i==2) {
			father=new Aurk();
		}
		return father;
	}
	
	//判断吃还是玩
	public void Type(Father father) {
		if(father instanceof Chinane) {
			Chinane chinane=(Chinane) father;
			chinane.Wang();
		}
		if(father instanceof Aurk) {
			Aurk aurk=(Aurk) father;
			aurk.Wang();
		}
	}

第四章 接口

含义:

接口是一套规范，只要是满足这个规范的设备，就可以将它们组装到一起，从而实现该设备的功能

语法:

接口

访问修饰符 interface 接口名 extends 接口1,接口2,..{
    //代码块
}

子类引用接口

访问修饰符 类名 implements 接口1,接口2..{
	//代码块
}

1.接口的特点

​ 1.接口不能被实例化

​ 2.成员方法: 只能是抽象方法,使用abstract修饰,默认访问修饰符是:pulic abstract

​ 3.成员变量: 只能定义静态常量,默认访问修饰发:public static final

​ 4.构造方法: 不能够有构造函数

作用:

​ 约束子类必须拥有某种行为

	相同点	不同点
		关键字	构造函数	成员变量
接口	都不能被实例化	interface	接口不能有构造函数	必须是:static final
抽象类	,约束子类必须实现抽象方法，除非子类也是抽象类,接口	abstract	抽象类可以有构造函数	抽象类可以有非静态的，可以不是常量

2.类的三个关系

​ is a:本质，继承
​ has a:属于,包含关系
​ like a:像，接口