JavaSE (面向对象)
JavaSE (面向对象)
写在前面:分享技术,共同进步,把之前写的笔记搬运至博客,有不足请见谅*,相关意见可评论告知 ╰( ̄ω ̄o)
编程路漫漫,学习无止尽!
面向对象三大特性: 封装,继承,多态
封装
封装的优点
1.提高程序的安全性,保护数据
2.隐藏代码的实现细节
3.统一接口
4.增加系统的可维护性
public class application {
public static void main(String[] args) {
final student s1 = new student(); //?
s1.money=1.0 ;
// s1.String ="" ; 报红因为私有
String name = s1.getName();
s1.setName("LZH");
System.out.println(s1.getName());
s1.setAge(12) ; // 不合法
System.out.println(s1.getAge());
}
}
//————————————————————————————————————————————————————————————————————————————————————————————
public class student {
// 封装一般对属性进行封装,方法也可,但一般不
// 属性私有
private String name;
private int id;
private char sex;
private int age;
public double money;
//但提供一些可以操作这个属性的方法
// 提供一些public 的get,set 方法
// get 获得这个数据
public String getName() {
return this.name;
}
// set 给这个数据设置值
public void setName(String name) {
this.name = name;
}
// 方法封装的应用
public int getAge() {
return age;
}
// 对其进行内部操作
public void setAge(int age) {
if (age > 120 || age < 0) {
this.age = 3;
} else {
this.age = age;
}
}
}
继承
继承图解
继承中成员变量的访问特点
在父子类的继承关系当中,如果成员变量重名,则创建子类对象时,访问有两种方式:
重要
- 直接通过子类对象访问成员变量:
等号左边是谁,就优先用谁,没有则向上找。 - 间接通过成员方法访问成员变量:
该方法属于谁(再哪里定义),就优先用谁,没有则向上找。
注意子类中三种成员变量重名的情况
局部变量 直接写成员变量名
本类的成员变量 this.成员变量名
父类的成员变量名 super.成员变量名
继承方法中的覆盖重写
方法覆盖重写的注意事项:
-
必须保证父子类之间方法的名称相同,参数列表也相同。
@Override:写在方法前面,用来检测是不是有效的正确覆盖重写。
这个注解就算不写,只要满足要求,也是正确的方法覆盖重写。 -
子类方法的返回值必须【小于等于】父类方法的返回值范围。
小扩展提示:java.lang.Object类是所有类的公共最高父类(祖宗类),java.lang.String就是Object的子类。 -
子类方法的权限必须【大于等于】父类方法的权限修饰符。
小扩展提示:public > protected > (default) > private
备注:(default)不是关键字default,而是什么都不写,留空。 -
成员变量是不能覆盖重写( @override )的 int num = 10 ;
设计原则
对于已经投入使用的类,尽量不要进行修改,推荐定义一个新的类,来重复利用其中的共性内容,并添加改动新内容。
在IDAE中查看树的快捷键 ctrl +H
值传递与引用传递
构造器
快捷键 alt + insert (生成构造器)
package oop.objectClass;
public class constructor_04 {
// 一个类即使什么都不写,他也会存在一个方法
// 显示定义的构造类
String name ;
// 实列化初始值
// 1.使用new关键字,本质是调用构造器
// 显化 无参构造
public constructor_04() {
this.name = "Qy";
}
// 有参构造 注意一旦定义了有参构造,无参就必须显示定义
public constructor_04(String name){
this.name = name ; // 前者name 为7行 String name 后者name为传进来name 18
}
}
//___________________________________________________________________________
package oop.objectClass;
// 一个项目中因该只有一个方法
public class Application_02 {
public static void main(String[] args) {
// 类 抽象的 实例化
// 类实列化后会返回一个自己的对象
// 以下第二个单词(student)就是一个Student 类的具体实列
// Student student = new Student() ;
// Student xiaoming = new Student() ;
// Student xiaohong = new Student() ; // 由于第一个单词报错
// 原因与类名相同 第二个单词 对象名可以不同
classAndObject_03 student = new classAndObject_03() ;
classAndObject_03 xiaoming = new classAndObject_03() ;
classAndObject_03 xiaohong = new classAndObject_03() ;
xiaoming.name ="小明" ;
xiaoming.age = 3 ;
System.out.println(xiaoming.name);
System.out.println(xiaoming.age);
System.out.println(xiaohong.name);
// constructor_04 部分·
constructor_04 constructor_04 = new constructor_04();
System.out.println(constructor_04.name);
}
}
Super
(一)继承关系中,父子类构造方法的访问特点:
- 子类构造方法当中有一个默认隐含的“super()”调用,所以一定是先调用的父类构造,后执行的子类构造。
- 子类构造可以通过super关键字来调用父类重载构造。
- super的父类构造调用,必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。
总结:
(二)子类必须调用父类构造方法,不写则赠送super();写了则用写的指定的super调用,super只能有一个,还必须是第一个。
(三)super关键字用来访问父类内容,而this关键字用来访问本类内容。用法也有三种:
- 在本类的成员方法中,访问本类的成员变量。
- 在本类的成员方法中,访问本类的另一个成员方法。
- 在本类的构造方法中,访问本类的另一个构造方法。
在第三种用法当中要注意:
A. this(...)调用也必须是构造方法的第一个语句,唯一一个 ※
B. super和this两种构造调用,不能同时使用。
※ 详细见图分析
super 注意点
1.super 调用父类的构造方法,必须在构造方法的第一个
2.super 必须只能出现在子类的方法或构造方法中
3.super 和 this 不能同时调用构造方法 (同为第一优先级矛盾)
super 与 this 的区别
两者关系图解
抽象方法与抽象类
抽象方法:就是加上abstract关键字,然后去掉大括号,直接分号结束。
抽象类:抽象方法所在的类,必须是抽象类才行。在class之前写上abstract即可。
如何使用抽象类和抽象方法:
- 不能直接创建new抽象类对象。
- 必须用一个子类来继承抽象父类。
- 子类必须覆盖重写抽象父类当中所有的抽象方法。
覆盖重写(实现):子类去掉抽象方法的abstract关键字,然后补上方法体大括号。 - 创建子类对象进行使用。
public abstract class Fu{
public abstract void eat() ;
}
使用注意事项
代码体现如下
j
多态
体现形式,父类引用指向子类对象。
格式:
父类名称 对象名 = new 子类名称()
接口名称 对象名 = new 实现类名称()
访问成员变量的两种方式:
- 直接通过对象名称访问成员变量:看等号左边是谁,优先用谁,没有则向上找。
- 间接通过成员方法访问成员变量:看该方法属于谁,优先用谁,没有则向上找。
多态方法的访问规则是:
看new的是谁,就优先用谁,没有则向上找。
口诀:编译看左边,运行看右边。
对比一下:
成员变量:编译看左边,运行看左边。
成员方法:编译看左边,运行看右边。
多态好处的实列体现:
对象的向上转型与向下转型
类比数据类型的转化:
低 -------------> 高
byte,short,char -> int -> long -> float -> double
package base;
public class typeCast_03 {
public static void main(String[] args) {
int i =128 ;
byte b = (byte)i ; // 内存溢出 // 强制转换
double c = i ; // 自动转换
// 强制转换 (类型)变量名 高 - 低
// 直动转换 低 - 高
System.out.println(i);
System.out.println(b);
System.out.println(c);
System.out.println("______");
// 例子2
char d = 'a' ;
int e =d+1 ; // 自动转换 低 - 高
System.out.println(e);
System.out.println((int)e); // 强制转换
int money = 10_0000_0000 ; // jdk7 新特性
int years = 20 ;
int total = money*years ; // 数据溢出
long total2 = money*years ; // 默认int 在转换之前已存在问题
// 正解
long total3 = money*((long)years) ;
System.out.println(total);
System.out.println(total2);
System.out.println(total3);
}
}
方法图解:
Instanceof
引言: 如何才能知道一个父类引用的对象,本来是什么类?如果希望调用子类特有方法,则需要向下转型。
instanceof 是 Java 的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例,返回 boolean 的数据类型。
格式
对象 instanceof 类名称
eg:
图解分析
面向对象小结
1.类与对象: 类是一个模板,抽象的,对象是一个具体的实列(先有对象再有类)
2.方法 : 定义,调用
3.对象的引用
引用类型,除八大基本类型外,对象是通过引用来操作的:栈 -> 堆
4.属性: 字符field 成员变量
默认初始化 数字0 0.0
char u0000
boolean false
引用 null
属性格式: 修饰符 属性类型 属性名 = 属性值
5、对象的创建和使用
必须使用new 关键字创造对象, 构造器 Person Qy new Qy() ;
对象的属性 Qy.name
对象的方法 Qy.sleep()
6.类: 静态的属性 属性 动态的行为 方法
写在最后:全栈方向,前端已经大部分学完,将会以复习的形式出现在博客,大家敬请期待哈~