1、类和对象
类的重要性:所有Java程序都以类class为组织单元
类是模子,确定对象将会拥有的特征(属性)和行为(方法)
类的组成:属性和方法
定义类:
public class 类名{ 属性+方法 }
把一个类变成一个对象:
创建对象:类名 对象名 = new 类名()【构造方法】;
使用对象:
2、成员变量和局部变量
成员变量:在类中定义
局部变量:在类的方法中定义
区别:
作用域不同
初始值不同,成员变量不需要初始化
局部变量在不同方法可以同名
成员变量和局部变量同名是,局部变量优先级高
3、构造方法
构造方法是定义在Java类中的一个用来初始化对象的方法
构造方法与类同名并且没有返回值类型
当没有指定构造方法时,系统会自动添加无参构造方法
当有指定构造方法,无论是有参、还是无参的构造方法,都不会自动添加无参的构造方法
构造方法的重载:方法名相同,但是参数不同的多个方法,调用时会自动根据不同的参数选择相应的方法
4、static 关键字
static使用之静态变量:
Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有,而不是某个对象所有,即被类的所有对象所共享。静态成员可以使用类名直接访问,也可以使用对象名进行访问。当然,鉴于他作用的特殊性更推荐用类名访问~~
使用 static 可以修饰变量、方法和代码块
static使用之静态方法:
1、 静态方法中可以直接调用同类中的静态成员,但不能直接调用非静态成员
如果希望在静态方法中调用非静态变量,可以通过创建类的对象,然后通过对象来访问非静态变量
2、 在普通成员方法中,则可以直接访问同类的非静态变量和静态变量
3、 静态方法中不能直接调用非静态方法,需要通过对象来访问非静态方法
public class HelloWorld(){ String name = "nyan"; static String hobby = "java"; public static void print(){ HelloWorld hello = new HelloWorld(); System.out.println(name);//错误 System.out.println(hello.name); System.out.println(hobby); } }
static使用之静态初始化块:
Java 中可以通过初始化块进行数据赋值
在类的声明中,可以包含多个初始化块,当创建类的实例时,就会依次执行这些代码块。如果使用 static 修饰初始化块,就称为静态初始化块。
需要特别注意:静态初始化块只在类加载时执行,且只会执行一次,同时静态初始化块只能给静态变量赋值,不能初始化普通的成员变量。
public class HelloWorld{ int num1; int num2; static int num3; public HelloWorld(){ num1 = 91; System.out.println("通过构造方法给num1赋值"); } { num2 = 74; System.out.println("通过构造方法给num1赋值"); } static { num3 = 84; System.out.println("通过构造方法给num1赋值"); } public static void main(String[] args){ HelloWorld hello = new HelloWorld(); System.out.println(hello.num1); System.out.println(hello.num1); System.out.println(num3); HelloWorld hello2 = new HelloWorld(); } }
程序运行时静态初始化块最先被执行,然后执行普通初始化块,最后才执行构造方法。由于静态初始化块只在类加载时执行一次,所以当再次创建对象 hello2 时并未执行静态初始化块。
5、封装
将类的某些信息隐藏在类内部,不允许外部程序直接访问,而通过该类提供的方法来实现对隐藏信息的操作和访问
好处:
只能通过规定的方法访问数据
隐藏类的实例细节,方便修改和实现
实现封装步奏:
修改属性的可见性private
创建getter/setter方法
在getter/setter方法中加入属性控制语句
Java中的包:
管理Java文件
解决同名文件
访问修饰符:
可以修饰属性和方法的访问范围
this关键字,代表当前对象
this.属性 操作当前对象的属性
this.方法 调用当前对象的方法
封装对象的属性的时候,经常会使用this关键字
6、Java 中的内部类
内部类( Inner Class )就是定义在另外一个类里面的类。与之对应,包含内部类的类被称为外部类。
内部类的主要作用:
1. 内部类提供了更好的封装,可以把内部类隐藏在外部类之内,不允许同一个包中的其他类访问该类
2. 内部类的方法可以直接访问外部类的所有数据,包括私有的数据
3. 内部类所实现的功能使用外部类同样可以实现,只是有时使用内部类更方便
内部类有几种:
成员内部类:
内部类中最常见的就是成员内部类,也称为普通内部类
1、 Inner 类定义在 Outer 类的内部,相当于 Outer 类的一个成员变量的位置,Inner 类可以使用任意访问控制符,如 public 、 protected 、 private 等
2、 Inner 类中定义的 test() 方法可以直接访问 Outer 类中的数据,而不受访问控制符的影响,如直接访问 Outer 类中的私有属性a
3、 定义了成员内部类后,必须使用外部类对象来创建内部类对象,而不能直接去 new 一个内部类对象,即:内部类 对象名 = 外部类对象.new 内部类( );
4、 编译上面的程序后,会发现产生了两个 .class 文件
其中,第二个是外部类的 .class 文件,第一个是内部类的 .class 文件,即成员内部类的 .class 文件总是这样:外部类名$内部类名.class
//外部类HelloWorld public class HelloWorld{ //外部类的私有属性name private String name = "imooc"; //外部类的成员属性 int age = 20; //成员内部类Inner public class Inner { String name = "爱慕课"; //内部类中的方法 public void show() { System.out.println("外部类中的name:" + HelloWorld.this.name); System.out.println("内部类中的name:" + name); System.out.println("外部类中的age:" + age); } } //测试成员内部类 public static void main(String[] args) { //创建外部类的对象 HelloWorld o = new HelloWorld (); //创建内部类的对象 Inner inn = o.new Inner(); //调用内部类对象的show方法 inn.show(); } }
静态内部类:
静态内部类是 static 修饰的内部类,这种内部类的特点是:
1、 静态内部类不能直接访问外部类的非静态成员,但可以通过 new 外部类().成员 的方式访问
2、 如果外部类的静态成员与内部类的成员名称相同,可通过“类名.静态成员”访问外部类的静态成员;如果外部类的静态成员与内部类的成员名称不相同,则可通过“成员名”直接调用外部类的静态成员
3、 创建静态内部类的对象时,不需要外部类的对象,可以直接创建 内部类 对象名= new 内部类();
//外部类 public class HelloWorld { // 外部类中的静态变量score private static int score = 84; // 创建静态内部类 public static class SInner { // 内部类中的变量score int score = 91; public void show() { System.out.println("访问外部类中的score:" + HelloWorld.score); System.out.println("访问内部类中的score:" + score); } } // 测试静态内部类 public static void main(String[] args) { // 直接创建内部类的对象 SInner si = new SInner(); // 调用show方法 si.show(); } }
方法内部类:
方法内部类就是内部类定义在外部类的方法中,方法内部类只在该方法的内部可见,即只在该方法内可以使用
由于方法内部类不能在外部类的方法以外的地方使用,因此方法内部类不能使用访问控制符和 static 修饰符。
//外部类 public class HelloWorld { private String name = "爱慕课"; // 外部类中的show方法 public void show() { // 定义方法内部类 class MInner { int score = 83; public int getScore() { return score + 10; } } // 创建方法内部类的对象 MInner mi = new MInner(); // 调用内部类的方法 int newScore = mi.getScore(); System.out.println("姓名:" + name + " 加分后的成绩:" + newScore); } // 测试方法内部类 public static void main(String[] args) { // 创建外部类的对象 HelloWorld mo = new HelloWorld(); // 调用外部类的方法 mo.show(); } }
匿名内部类
7、继承
好处:
子类拥有父类的所有属性和方法
extends关键字
方法的重写:
如果子类对父类的方法不满意,是可以重写父类继承的方法的,当调用方法时会优先调用子类的方法
返回值类型、方法名、参数类型及个数 都要与父类继承的方法相同
继承的初始化顺序
初始化父类在初始化子类
先执行初始化对象中属性,再执行构造方法中的初始化
super关键字:
在对象的内部使用,可以代表父类对象。
super();//父类的构造方法,会隐式调用
Object类
toString()方法
public String toString(){ return "Dog[age+age+"]"; } Dog dog = new Dog(); syso(dog);
equals()方法
比较的是对象的引用是否指向同一块内存地址
8、多态
对象的多种形态,继承是实现多态的基础
引用的多态:
父类的引用可以指向本类的对象:Animal an = new Animal();
父类的引用可以指向子类的对象: Animal dog = new Dog();
方法的多态:
创建本类对象时,调用的方法为本类的方法
创建子类对象时,调用的方法为子类重写的方法或者继承的方法
引用类型进行转换:
1、向上类型转换(隐式/自动类型转换)
2、大类型转换小类型(强制转换)
3、instanceOf运算符,来解决引用对象的类型,避免类型转换的安全性问题
抽象类:
在某些情况下,某个父类只是知道其子类应该包含怎样的方法,但无法准确知道这些子类如何实现这些方法‘
不关注子类的实现,但必须规定子类实现某些方法
使用规则:
abstract 定义抽象类
abstract定义抽象方法,只是声明,不需要实现
包含抽象 方法的类是抽象类
抽象类中可以包含普通方法,也可以没有抽象方法
抽象类不能直接创建,可以定义引用变量
接口:
接口可以理解为一种特殊的类,由全局常量和公共的抽象方法所组成。
常量:接口的属性是常量,即使不添加public static final 修饰符,系统也会自动加上。
方法:接口中的方法只能是抽象方法,总是使用,即使定义时不添加public abstact修饰符,系统也会加速上