涉及知识点总览
- 类
- 对象
- 构造方法
- 引用与对象实例
- static
- final
- 封装
- 继承
- 方法重载与重写
- 多态
- 抽象类
- 接口
- 内部类
1. 语法
- this指针
if(this.sex==0)//this用的是点……
- 类变量: 也叫静态变量,类变量也声明在类中,方法体之外,但必须声明为 static 类型。
- 成员变量和局部变量同名时,局部变量具有更高的优先级。 大家可以编写代码验证一下。
- 创建对象
People LiLei = new People();//实例化类,调用构造方法People()
- 权限修饰符
public People(){}
public People(int age){}
对象实例?引用?
在新建对象实例时,需要为对象实例设置一个对象名,就像这样
Object object=new Object();
- 那么变量 object 就真的是 Object 对象么?这里其实只是创建了一个 object 对象的引用。和c语言的指针一样,变量 object 保存的其实 Object 对象的引用,指向了 Object 对象。
---------- ----------
| object |---------> | Object |
---------- ----------
| | | |
---------- ----------
| | | |
---------- ----------
| | | |
---------- ----------
| | | |
---------- ----------
- 再看下面的例子
Object object1 = new Object();
Object object2 = object1;
System.out.println(object1 == object2);//true
- 运行得到的结果为 true,说明 object1 和 object2 的内存地址相同
(== 会比较两个对象的内存地址是否相同)
它们实际上是引用同一对象,如果改变 object1 对象内部的属性,那么 object2 的属性同样会改变
静态成员
Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有,而不是某个对象所有,即被类的所有对象所共享。静态成员可以使用类名直接访问,也可以使用对象名进行访问。
如:
public class StaticTest{
public static String string="shiyanlou";
public static void main(String[] args){
//静态成员不需要实例化 直接就可以访问
System.out.println(StaticTest.string);
//如果不加static关键字 需要这样访问
StaticTest staticTest=new StaticTest();
System.out.println(staticTest.string);
//如果加上static关键字,上面的两种方法都可以使用
}
}
静态方法
- 被 static 修饰的方法是静态方法,静态方法不依赖于对象,不需要将类实例化便可以调用,由于不实例化也可以调用,所以不能有 this(因为this代表的是调用这个函数的对象的引用,而静态方法是属于类的,不属于对象,静态方法成功加载后,对象还不一定存在),也不能访问非静态成员变量和非静态方法(原因同上,非静态的变量和方法是属于对象的)。但是非静态成员变量和非静态方法可以访问静态方法。
final
- final 关键字可以修饰类、方法、属性和变量
- final 修饰类,则该类不允许被继承,为最终类
- final 修饰方法,则该方法不允许被覆盖(重写)
- final 修饰属性:则该类的属性不会进行隐式的初始化(类的初始化属性必须有值)或在构造方法中赋值(但只能选其一)
- final 修饰变量,则该变量的值只能赋一次值,即常量
权限修饰符/访问控制符(详)
- 说明
- 示意图
- 访问private属性
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
注意:
- Eclipse 和 IDEA 等 IDE 都有自动生成 getter 和 setter 方法的功能
- 当成员变量和局部变量之间发生冲突时(优先访问局部变量),在属性名前面添加了 this 关键字。 此时就代表将一个参数的值赋给当前对象的属性。同理 this 关键字可以调用当前对象的方法
继承
语法
public class Dog extends Animal {}
注意
- Java 中的继承是单继承,一个类只有一个父类。
- Java 实现多继承的一个办法是** implements(实现)接口**,但接口不能有非静态的属性,这一点请注意
super 关键字
super 关键字在子类内部使用,代表父类对象。
- 访问父类的属性 super.属性名。
- 访问父类的方法 super.bark()。
- 子类构造方法需要调用父类的构造方法时(不是,什么时候不需要吗。。),在子类的构造方法体里最前面的位置:super()(也就是必须要加,不加的话也会默认自动加上)
方法重载
- 重载的方法中允许抛出不同的异常
- 可以有不同的返回值类型,但是参数列表必须不同。
- 可以有不同的访问修饰符。
方法重写
- 子类方法重写后,在调用方法中,优先调用子类的方法
- 重写的方法一定要与原父类的方法语法保持一致,比如返回值类型,参数类型及个数,和方法名都必须一致
- 关于如下用法:
public class Animal{}
public class Dog extends Animal{};
Animal b = new Dog();
这里创建了一个Dog 对象,向上转型为Animal类型,具体会在实验楼后面的内容进行详解
多态
- 也称作动态绑定(dynamic binding),是指在执行期间判断所引用对象的实际类型,根据其实际的类型调用其相应的方法
- 多态的实现条件:
Java 实现多态有三个必要条件:继承、重写和向上转型(即父类引用指向子类对象)。 - 多态的实现方式:
Java 中多态的实现方式:继承父类进行方法重写,抽象类和抽象方法,接口实现
向上转型
- 不能使用一个子类的引用去指向父类的对象,因为子类对象中可能会含有父类对象中所没有的属性和方法
- 如果定义了一个指向子类对象的父类引用类型,那么它除了能够引用父类中定义的所有属性和方法外,还可以使用子类强大的功能。但是对于只存在于子类的方法和属性就不能获取(这个很重要)
- 向上转型,在运行时,会覆盖与父类中相同的方法——重写(方法名,参数都相同)
抽象类
- 抽象类是限制规定子类必须实现某些方法,但不关注实现细节
- 包含抽象方法的类就是抽象类
- 用 abstract 修饰符定义抽象类
- 用 abstract 修饰符定义抽象方法,只用声明,不需要实现
- 抽象类中可以包含普通的方法,也可以没有抽象方法
- 抽象类的对象不能直接创建,通常是定义引用变量指向子类对象
接口
- 接口:描述类所具有的功能,不提供功能的实现,
- 实现接口的类:功能的实现中
- 声明语法格式
修饰符 interface 接口名称 [extends 其他的接口名] {
// 声明变量
// 抽象方法
}
- 在 Java8 中:
- 接口不能用于实例化对象。
- 接口中方法只能是抽象方法、default 方法、静态方法。
- 接口成员是 static final 类型。
- 接口支持多继承。
- 在 Java9 中,接口可以拥有私有方法和私有静态方法,但是只能被该接口中的 default 方法和静态方法使用。
多继承实现方式
修饰符 interface A extends 接口1,接口2{ }
修饰符 class A implements 接口1,接口2{ }
- 作业题
// Animal.java
interface Animal {
//int x;
//编译错误,x需要初始化,因为是 static final 类型
int y = 5;
public void eat();
public void travel();
}
// Cat.java
public class Cat implements Animal{
public void eat(){
System.out.println("Cat eats");
}
public void travel(){
System.out.println("Cat travels");
}
public static void main(String[] args) {
Cat cat = new Cat();
cat.eat();
cat.travel();
}
}
内部类
- 将一个类的定义放在另一个类的定义内部,这就是内部类。而包含内部类的类被称为外部类。
- 作用
- 不允许同一个包中的其他类访问该类
- 内部类的方法可以直接访问外部类的所有数据,包括私有的数据
- 内部类允许继承多个非接口类型
注:内部类是一个编译时的概念,一旦编译成功,就会成为完全不同的两类。对于一个名为 outer 的外部类和其内部定义的名为 inner 的内部类。编译完成后出现 outer.class 和 outer$inner.class 两类。所以内部类的成员变量 / 方法名可以和外部类的相同。
- 我们来看一下实验楼给的案例:
// People.java
//外部类People
public class People {
private String name = "LiLei"; //外部类的私有属性
//内部类Student
public class Student {
String ID = "20151234"; //内部类的成员属性
//内部类的方法
public void stuInfo(){
System.out.println("访问外部类中的name:" + name);
System.out.println("访问内部类中的ID:" + ID);
}
}
//测试成员内部类
public static void main(String[] args) {
People a = new People(); //创建外部类对象,对象名为a
Student b = a.new Student(); //使用外部类对象创建内部类对象,对象名为b
// 或者为 People.Student b = a.new Student();
b.stuInfo(); //调用内部对象的suInfo方法
}
}
- 成员内部类的使用方法:
- Student 类相当于 People 类的一个成员变量,所以 Student 类可以使用任意访问修饰符。
- Student 类在 People 类里,所以访问范围在类里的所有方法均可以访问 People 的属性(即内部类里可以直接访问外部类的方法和属性,反之不行)。
- 定义成员内部类后,必须使用外部类对象来创建内部类对象,即 内部类 对象名 = 外部类对象.new 内部类();。
- 如果外部类和内部类具有相同的成员变量或方法,内部类默认访问自己的成员变量或方法,如果要访问外部类的成员变量,可以使用 this 关键字。如上述代码中:a.this。
注:成员内部类不能含有 static 的变量和方法,因为成员内部类需要先创建外部类,才能创建它自己的。
静态内部类 (嵌套类)
- 静态内部类是 static 修饰的内部类,这种内部类的特点是:
- 静态内部类不能直接访问外部类的非静态成员,但可以通过 new 外部类().成员 的方式访问。
- 如果外部类的静态成员与内部类的成员名称相同,可通过 类名.静态成员 访问外部类的静态成员;如果外部类的静态成员与内部类的成员名称不相同,则可通过 成员名 直接调用外部类的静态成员。
- 创建静态内部类的对象时,不需要外部类的对象,可以直接创建 内部类 对象名 = new 内部类();。
- 案例
// People.java
//外部类People
public class People {
private String name = "LiLei"; //外部类的私有属性
/*外部类的静态变量。
Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有,而不是某个对象所有,即被类的所有对象所共享。静态成员可以使用类名直接访问,也可以使用对象名进行访问。*/
static String ID = "510xxx199X0724XXXX";
//静态内部类Student
public static class Student {
String ID = "20151234"; //内部类的成员属性
//内部类的方法
public void stuInfo(){
System.out.println("访问外部类中的name:" + (new People().name));
System.out.println("访问外部类中的ID:" + People.ID);
System.out.println("访问内部类中的ID:" + ID);
}
}
//测试成员内部类
public static void main(String[] args) {
Student b = new Student(); //直接创建内部类对象,对象名为b
b.stuInfo(); //调用内部对象的suInfo方法
}
}
局部内部类
- 局部内部类也像别的类一样进行编译,但只是作用域不同而已,只在该方法或条件的作用域内才能使用,退出这些作用域后无法引用的
- 案例
// People.java
//外部类People
public class People {
//定义在外部类中的方法内:
public void peopleInfo() {
final String sex = "man"; //外部类方法中的常量
class Student {
String ID = "20151234"; //内部类中的常量
public void print() {
System.out.println("访问外部类的方法中的常量sex:" + sex);
System.out.println("访问内部类中的变量ID:" + ID);
}
}
Student a = new Student(); //创建方法内部类的对象
a.print();//调用内部类的方法
}
//定义在外部类中的作用域内
public void peopleInfo2(boolean b) {
if(b){
final String sex = "man"; //外部类方法中的常量
class Student {
String ID = "20151234"; //内部类中的常量
public void print() {
System.out.println("访问外部类的方法中的常量sex:" + sex);
System.out.println("访问内部类中的变量ID:" + ID);
}
}
Student a = new Student(); //创建方法内部类的对象
a.print();//调用内部类的方法
}
}
//测试方法内部类
public static void main(String[] args) {
People b = new People(); //创建外部类的对象
System.out.println("定义在方法内:===========");
b.peopleInfo(); //调用外部类的方法
System.out.println("定义在作用域内:===========");
b.peopleInfo2(true);
}
}
匿名内部类
- 顾名思义,就是没有名字的内部类。正因为没有名字,所以匿名内部类只能使用一次,它通常用来简化代码编写。但使用匿名内部类还有个前提条件:必须继承一个父类或实现一个接口。
- 例
// Outer.java
public class Outer {
public Inner getInner(final String name, String city) {
return new Inner() {
private String nameStr = name;
public String getName() {
return nameStr;
}
};
}
public static void main(String[] args) {
Outer outer = new Outer();
Inner inner = outer.getInner("Inner", "NewYork");
System.out.println(inner.getName());
}
}
interface Inner {
String getName();
}
运行结果:Inner。
- 匿名内部类是不能加访问修饰符的。要注意的是,new 匿名类,这个类是要先定义的, 如果不先定义,编译时会报错该类找不到。
- 同时,在上面的例子中,当所在的方法的形参需要在内部类里面使用时,该形参必须为** final**。这里可以看到形参 name 已经定义为 final 了,而形参 city 没有被使用则不用定义为 final。
- 然而,因为匿名内部类没名字,是用默认的构造方法的,无参数的,如果需要该类有带参数的构造方法,示例如下:
public Inner getInner(final String name, String city) {
return new Inner(name, city) {
private String nameStr = name;
public String getName() {
return nameStr;
}
};
}
- 这里的city,由于它没有被匿名内部类直接使用,而是被抽象类 Inner 的构造方法所使用,所以不必定义为 final
package
- 包采用了树形目录的存储方式。同一个包中的类名字是不同的,不同的包中的类的名字是可以相同的,当同时调用两个不同包中相同类名的类时,应该加上包名加以区别
2. 一些其他的东西
- 智障报错:非法字符: ‘\uff1b’ = 分号写成中文
- 浮点数的表示:34.56
- 命令行 编译多个文件:
javac Test.java Dog.java Animal.java