涉及知识点总览
- 类
- 对象
- 构造方法
- 引用与对象实例
- 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
扫一扫
1264
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
