⭐ 变量的分类和作用域
变量有三种类型:局部变量、成员变量(也称为实例变量)和静态变量。
局部变量、成员变量、静态变量的核心区别
类型 | 声明位置 | 从属于 | 生命周期(作用域) |
---|---|---|---|
局部变量 | 方法或语句块内部 | 方法/语句块 | 从声明处开始,到方法或语句块结束 |
成员变量(实例变量) | 类内部,方法外部 | 对象 | 对象创建,成员变量也跟着创建,对象消失,成员变量也跟着消失 |
静态变量(类变量) | 类内部,static修饰 | 类 | 类被加载,静态变量就有效 |
⭐ 包机制(package、import)
包(package)相当于文件夹对于文件的作用。用于管理类、用于解决类的重名问题。
package
package 的使用有两个要点:
🐟 通常是类的第一句非注释性语句。
🐟 包名:域名倒着写即可,便于内部管理类。
【eg】package 的命名演示
com.oracle.test;
com.it.wang.test;
com.it.wang.view;
com.it.view.model;
注意:
🐟 写项目时都要加包,不要使用默认包。
🐟 com.wang 和 com.wang.car,这是两个完全独立的包。只是逻辑上看,后者是前者的一部分。
【eg】package 的使用
package com.oldwang;
public class Test {
public static void main(String[ ] args) {
System.out.println("helloworld");
}
}
⭐ 在 IDEA 项目中新建包
在 src 目录上单击右键,选择 new->package,创建 package
在 package 窗口上输入包名即可
点击 OK,即可在 src 下面看到包:
接下来,我们就可以在包上单击右键,新建类啦!
JDK 中的主要包
Java中的常用包 | 说明 |
---|---|
java.lang | 包含一些Java语言的核心类,如String、Math、Integer、System和Thread |
java.avt | 包含了构成抽象窗口工具集(abstract windows toolkits)的多个类,这些类被用来构建和管理应用程序的图形用户界面(GUI) |
java.net | 包含执行与网络相关的操作的类 |
java.io | 包含能提供多种输入/输出功能的类 |
java.util | 包含一些使用工具类,如定义系统特性、使用与日期日历相关的函数 |
⭐ 导入类 import
如果要使用其他包的类,需使用 import,从而在本类中直接通过类名来调用,否则就需要书写类的完整包名和类名。
注意:
🐟 Java 会默认导入 java.lang 包下所有的类,因此这些类我们可以直接使用。
🐟 如果导入两个同名的类,只能用包名+类名来显示调用相关类:
🐟 java.util.Date date = new java.util.Date();
⭐ 静态导入
静态导入(static import): 其作用是用于导入指定类的静态属性和静态方法,这样我们可以直接使用静态属性和静态方法。
【eg】静态导入的使用
package oldwang;
import static java.lang.Math.*;//导入Math类的所有静态属性
import static java.lang.Math.PI;//导入Math类的PI属性
public class Test{
public static void main(String [ ] args){
System.out.println(PI);
System.out.println(random());
}
}
执行结果如下所示:
⭐ 面向对象三大特征——继承
继承是面向对象编程的三大特征之一。继承让我们更加容易实现类的扩展。实现代码的重用,不用再重新发明轮子(don’t reinvent wheels)。
⭐ 继承的作用
🐟 代码复用,更加容易实现类的扩展
🐟 方便建模
⭐ 继承的实现
从英文字面意思理解,extends 的意思是“扩展”。子类是父类的扩展。现实世界中的继承无处不在。比如:
上图中,哺乳动物继承了动物。意味着,动物的特性,哺乳动物都有;在我们编程中,如果新定义一个Student类,发现已经有 Person类包含了我们需要的属性和方法,那么 Student类只需要继承 Person 类即可拥有 Person 类的属性和方法。
【eg】使用 extends 实现继承
public class Test{
public static void main(String[ ] args) {
Student s = new Student("OldWang",183,"Java");
s.rest();
s.study();
}
}
class Person {
String name;
int height;
public void rest(){
System.out.println("休息一会!");
}
}
class Student extends Person {
String major; //专业
public void study(){
System.out.println("在CSDN,学习Java");
}
public Student(String name,int height,String major) {
//天然拥有父类的属性
this.name = name;
this.height = height;
this.major = major;
}
}
⭐ instanceof 运算符
instanceof 是二元运算符,左边是对象,右边是类;当对象是右面类或子类所创建对象时,返回 true;否则,返回 false。比如:
【eg】使用 instanceof 运算符进行类型判断
public class Test{
public static void main(String[ ] args) {
Student s = new Student("OldWang",183,"Java");
System.out.println(s instanceof Person);
System.out.println(s instanceof Student);
}
}
两条语句的输出结果都是 true。
⭐ 继承使用要点
🐟 父类也称作超类、基类。 子类:派生类等。
🐟 Java 中只有单继承,没有像 C++那样的多继承。多继承会引起混乱,使得继承链过于复杂,系统难于维护。
🐟 Java 中类没有多继承,接口有多继承。
🐟 子类继承父类,可以得到父类的全部属性和方法 (除了父类的构造方法),但不见得可以直接访问(比如,父类私有的属性和方法)。
🐟 如果定义一个类时,没有调用 extends,则它的父类是:java.lang.Object。
⭐ 方法重写 override
子类重写父类的方法,可以用自身行为替换父类行为。重写是实现多态的必要条件。
方法重写需要符合下面的三个要点:
🐟 “= =”: 方法名、形参列表相同。
🐟 “≤”:返回值类型和声明异常类型,子类小于等于父类。
🐟 “≥”: 访问权限,子类大于等于父类。
【eg】方法重写
package oldwang;
/**
* 测试方法的重写
*/
public class TestOverride {
public static void main(String[ ] args) {
Horse h = new Horse();
Plane p = new Plane();
h.run();
h.getVehicle();
p.run();
}
}
class Vehicle { //交通工具类
public void run() {
System.out.println("跑....");
}
public Vehicle getVehicle(){
System.out.println("给你一个交通工具!");
return null;
}
}
class Horse extends Vehicle { // 马也是交通工具
@Override
public void run() {
System.out.println("得得得....");
}
@Override
public Horse getVehicle() {
return new Horse();
}
}
class Plane extends Vehicle {
@Override
public void run() {
System.out.println("天上飞....");
}
}
⭐ final 关键字
final 关键字的作用:
🐟 修饰变量: 被他修饰的变量不可改变。一旦赋了初值,就不能被重新赋值。final int MAX_SPEED = 120;
🐟 修饰方法:该方法不可被子类重写。但是可以被重载! final void study(){}
🐟 修饰类: 修饰的类不能被继承。比如:Math、String 等。
⭐ 继承和组合
除了继承,"组合"也能实现代码的复用,“组合"核心是"将父类对象作为子类的属性”。
public class Test{
public static void main(String[ ] args) {
Student s = new Student("OldWang",183,"Java");
s.person.rest(); //s.rest();
s.study();
}
}
class Person {
String name;
int height;
public void rest(){
System.out.println("休息一会!");
}
}
class Student /*extends Person*/ {
Person person = new Person();
String major; //专业
public Student(String name,int height,String major) {
//拥有父类的对象,通过这个对象间接拥有它的属性和方法
this.person.name = name; //this.name = name;
this.person.height = height; //this.height = height;
this.person.rest();
this.major = major;
}
}
组合比较灵活。继承只能有一个父类,但是组合可以有多个属性。所以,有人声称"组合优于继承,开发中可以不用继承",但是,不建议大家走极端。
对于"is -a"关系建议使用继承,"has-a"关系建议使用组合。
比如:上面的例子,Student is a Person 这个逻辑没问题,但是:Student has a Person就有问题了。这时候,显然继承关系比较合适。
再比如:笔记本和芯片的关系显然是"has-a"关系,使用组合更好。