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#:
-
C#中static成员只能够通过类名点
-
Java中的还可以通过对象名,但建议还是使用类名(原因:static成员属于类成员而不是对象成员)
-
修饰的成员 字段,方法,但是属于类,对象名,但建议还是使用类名
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:像，接口
864
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
