目录
类变量(静态变量)
类方法(静态方法)
Main方法public static void main(String[] arg){}
代码块
单例设计模式
final关键字
抽象类
抽象模板模式
接口
内部类
2-1:局部内部类
2-2:匿名内部类
2-3成员内部类
2-4静态内部类
类变量(静态变量)
①静态变量,可以被同一个类的多个对象实例共享;
可以通过类名直接访问。【也要满足访问权限】
②Static变量在类加载的时候生成的;
不需要实例化就可以通过 类名.类变量 来访问
Static变量保存的在class实例的尾部,class对象在堆中;
类方法(静态方法)
当我们不希望创建实例,也可以调用某个方法【当作工具】,我们就可以做成静态方法。
- 类方法中,不允许使用和对象有关的关键字,(this、super)----普通方法可以。
- 静态方法只能访问静态的成员; 【遵守访问权限】
- 非静态的方法可以访问静态和非静态的成员; 【遵守访问权限】
Main方法public static void main(String[] arg){}
- Main方法是由Java的虚拟机调用的;
- Java虚拟机需要调用main方法,所以main必须是public
- Java虚拟机在执行main方法时,不必创建对象,所以用static;
- 该方法接收String类型的数组参数,该数组中保存执行java命令时传递给所运行的类的参数,【案例】
- Java执行的程序 参数1 参数2 参数3、、、【例】
-
![韩顺平Java学习 面向对象【高级】(笔记)_第1张图片](http://img.e-com-net.com/image/info8/240b307dfe50402b99c754539f57e155.jpg)
![韩顺平Java学习 面向对象【高级】(笔记)_第2张图片](http://img.e-com-net.com/image/info8/bf6bbe4b03984c63a85e558f653f88c7.jpg)
——静态方法main如果要访问非静态的成员,先创建对象,在调用!
代码块
基本介绍:
1、代码块(又称:初始化块),属于类中的成员(类的一部分),类似于方法,将逻辑语句封装在方法体中,通过 { } 包围起来。
2、和方法不同,没有方法名,没有返回,没有参数,只有方法体。
不用通过对象或类显式调用, 是加载类时或创建对象时隐式调用;
3、修饰符可以写static,静态代码块; ——或普通代码块;
[修饰符] {
代码
}
理解:
相当于另外一种形式的构造器,(对构造器的补充机制),可以做初始化操作;
Eg:
如果多个构造器中,出现重复的语句,可以抽取出来,放到初始化代码块中,提高代码的重用性;
代码块调用顺序优先于构造器;
![韩顺平Java学习 面向对象【高级】(笔记)_第3张图片](http://img.e-com-net.com/image/info8/7b79ab8b95384bfd8d43777e308afd96.jpg)
细节:
- Static代码块,作用是对类进行初始化,而且随着类的加载而执行。并且只会执行一次,如果是普通的代码块,每创建一个对象,就执行。
- 类什么时候被加载:
创建对象示例时;
创建子类对象,父类也被加载;
使用类的静态成员时(静态属性,静态方法);
- 普通的代码块,在创建对象实例时,会被隐式的调用。
创建一次就调用一次。
如果,只是使用类的静态成员时,普通代码块并不会执行;
- 创建一个对象时,在一个类中的调用顺序:
·调用静态代码块和静态属性初始化,两种都按顺序调用。
·再调用普通代码块和普通属性初始化,顺序调用;
·最后,调用构造方法
- 构造器 的最前面其实隐含了super()和调用普通代码块。
![韩顺平Java学习 面向对象【高级】(笔记)_第4张图片](http://img.e-com-net.com/image/info8/25d45f45727d4ef8bb8e0d13a3e7990b.jpg)
- 先静态,先父类。
![韩顺平Java学习 面向对象【高级】(笔记)_第5张图片](http://img.e-com-net.com/image/info8/f0d9119fbc604d11aef9d13cf53a599b.jpg)
静态代码块只能调用静态成员;普通代码块可以调用任意成员;
Exercise:
![韩顺平Java学习 面向对象【高级】(笔记)_第6张图片](http://img.e-com-net.com/image/info8/880e1f584cd845feada842aafbf290e9.jpg)
共有23种设计模式;
- 设计模式:静态方法和属性的经典使用;
- 设计模式是在大量的实践中总结和理论之后优选的代码结构、编程风格、以及解决问题的思考方式
单例模式(饿汉式、懒汉式)
![韩顺平Java学习 面向对象【高级】(笔记)_第7张图片](http://img.e-com-net.com/image/info8/d61e578cb07744be9f2e3207cfac03ab.jpg)
- 饿汉式:不管用不用,它都先把对象创建好了;可能造成资源浪费
第一步:将构造器私有化,保证只能有一个实例化对象
第二步:在类内部创建一个对象
第三步:提供一个static方法,这样返回一个girlfriend对象,
// 可以不需要去实例化,在main中只需要调用方法,就能返回 对象;
- public class SingleTom {
- public static void main(String[] args) {
- girlfriend instance = girlfriend.getInstance();
- System.out.println(instance);
- }
- }
- class girlfriend{
- private String name;
- //第二步:在类内部创建一个对象:
- private static girlfriend qq=new girlfriend("qq");
- //这里的static为了能在静态方法中返回;
-
- //第一步:将构造器私有化——》保证只能有一个实例化对象
- private girlfriend(String name) {
- this.name = name;
- }
-
- @Override
- public String toString() {
- return "girlfriend{" +
- "name='" + name + '\'' +
- '}';
- }
-
- //第三步:提供一个static方法,这样返回一个girlfriend对象,
- // 可以不需要去实例化,在main中只需要调用方法,就能返回qq;
- public static girlfriend getInstance(){
- return qq;
- }
- }
- 懒汉式:只有当用户使用getinstance()时,才返回对象;再次调用返回上一次创建的对象; 从而保证单例;
可能存在线程安全问题;
- //懒汉式的单例模式;
- public class SingleTom2 {
- public static void main(String[] args) {
- Cat instance = Cat.getInstance();
- System.out.println(instance);
- }
- }
- class Cat{
- private String name;
- //第二步:在类内部创建一个对象:
- private static Cat cat;
- //这里的static为了能在静态方法中返回;
-
- //第一步:将构造器私有化——》保证只能有一个实例化对象
- private Cat(String name) {
- this.name = name;
- }
-
-
- @Override
- public String toString() {
- return "Cat{" +
- "name='" + name + '\'' +
- '}';
- }
-
- //第三步:提供一个static方法,这样返回一个Cat对象,
- // 可以不需要去实例化,在main中只需要调用方法,就能返回qq;
- public static Cat getInstance(){
- if (cat == null) {
- cat=new Cat("xx");
- }
- return cat;
- }
- }
3、小结
![韩顺平Java学习 面向对象【高级】(笔记)_第8张图片](http://img.e-com-net.com/image/info8/599e9e4050fe4a888e38f372f5e74bef.jpg)
- 不希望某个类被继承,可以用final修饰类;——>final class A{}
- 不希望父类的某个方法被重写,可以用final修饰方法。
- 不希望类的某个属性被修改,可以用final修饰属性。
- 不希望某个局部变量被修改,也可也用final修饰变量;
![韩顺平Java学习 面向对象【高级】(笔记)_第9张图片](http://img.e-com-net.com/image/info8/95c24708aa664d478b8596a3ad8ce0f7.jpg)
![韩顺平Java学习 面向对象【高级】(笔记)_第10张图片](http://img.e-com-net.com/image/info8/90dc738c1c8a4a208e5f26330b0a6b5c.jpg)
当父类的一些方法不能确定时,可以用abstract关键字来修饰该方法,这个方法就是抽象方法,用abstract来修饰该类就是抽象类;
一般来说,抽象类会被子类继承,由子类来实现抽象方法;
细节:
![韩顺平Java学习 面向对象【高级】(笔记)_第11张图片](http://img.e-com-net.com/image/info8/5ca6dd86ea7749dda0a359154ac62aa4.jpg)
![韩顺平Java学习 面向对象【高级】(笔记)_第12张图片](http://img.e-com-net.com/image/info8/33b5a1548de14b3b948ca14341417703.jpg)
注释:static修饰的方法必须有方法体,抽象方法没有。
抽象模板模式
D:\IDEAproject\basis2\src\com\cc\Abstract\exercise2
![韩顺平Java学习 面向对象【高级】(笔记)_第13张图片](http://img.e-com-net.com/image/info8/1933be8318364c44ab4edd15151939fe.jpg)
1、接口,就是给出一些没有实现的方法,封装到一起,到某个类要使用的时候,在根据具体情况把这些方法写出来。写法:
![韩顺平Java学习 面向对象【高级】(笔记)_第14张图片](http://img.e-com-net.com/image/info8/4346cc3cefee46f6a90445ca32adb53f.jpg)
2、难的是,如何去使用;
[D:\IDEAproject\basis2\src\com\cc\Interface]
![韩顺平Java学习 面向对象【高级】(笔记)_第15张图片](http://img.e-com-net.com/image/info8/dd52d7eaf9614f9689559d061d2100ba.jpg)
![韩顺平Java学习 面向对象【高级】(笔记)_第16张图片](http://img.e-com-net.com/image/info8/558c8272d4bc47f7aa7bb745f32c7a63.jpg)
![韩顺平Java学习 面向对象【高级】(笔记)_第17张图片](http://img.e-com-net.com/image/info8/0d584794fff44beebee847998e8ecd7d.jpg)
3、实现接口和继承类的区别,联系;
![韩顺平Java学习 面向对象【高级】(笔记)_第18张图片](http://img.e-com-net.com/image/info8/40bd1b6c1a53477c89befc5a8942fbc5.jpg)
当子类继承父类,就自动继承了父类的功能;
如果子类需要扩展功能,可以通过实现接口的方式来扩展;
可以理解为【接口,是对java的单继承机制的一种补充】
D:\IDEAproject\basis2\src\com\cc\extends_interface\extends_interface.java
![韩顺平Java学习 面向对象【高级】(笔记)_第19张图片](http://img.e-com-net.com/image/info8/1895aed906144071beccffed1fe7dddb.jpg)
4、
![韩顺平Java学习 面向对象【高级】(笔记)_第20张图片](http://img.e-com-net.com/image/info8/aded848920424c71bff9a8367c46b20d.jpg)
- public class InterfacePolyParameter {
- public static void main(String[] args) {
- //接口的多态体现
- USBinterface phone = new phone();
- phone=new car();
- }
- }
- interface USBinterface{}
- class phone implements USBinterface{}
- class car implements USBinterface{}
数组:
- public class InterfacePolyArr {
- public static void main(String[] args) {
- //接口类型的 多态数组
- USB[] usb = new USB[2];
- usb[0] =new Iphone();
- usb[1]=new Icar();
- for (int i = 0; i < usb.length; i++) {
- usb[i].work();//动态绑定。
- //向下转型;
- if (usb[i] instanceof Iphone) {//判断运行类型;
- ((Iphone) usb[i]).call();
- }
- }
- }
- }
- interface USB{
- void work();
- }
- class Iphone implements USB{
- void call(){
- System.out.println("myphone lllllllll");
- }
-
- @Override
- public void work() {
- System.out.println("phone working ---");
- }
- }
- class Icar implements USB{
- @Override
- public void work() {
- System.out.println("car working ---");
- }
- }
多态传递:
- public class InterfacePolyPass {
- public static void main(String[] args) {
- ia a = new C(); //如果 ib 没有extends ia无法创建
- ib b=new C();
- }
- }
- interface ia{}
- interface ib extends ia{}
- class C implements ib{}
Tip:
普通的类实现一个接口时,可以用alt+shift+enter或alt+enter快速创建抽象类的所有方法;
- 介绍:
一个类的内部有完整的嵌套了另一个类结构。被嵌套的叫内部类(inner class)
嵌套其他类的类叫外部类(outer class)。
内部类的最大特点:能直接访问私有属性,并且可以体现类与类之间的包含关系;
类的五大成员:【属性,方法,构造器,代码块,内部类】
- 内部类的分类
![韩顺平Java学习 面向对象【高级】(笔记)_第21张图片](http://img.e-com-net.com/image/info8/ce884bded1a74218ac56bd42182fe886.jpg)
2-1:局部内部类
在外部类的局部位置;
- 可以直接访问外部类的所有成员
- 不能添加访问修饰符,但可以final修饰;
- 作用域在方法体或代码块中
- 本质仍然是一个类;
![](http://img.e-com-net.com/image/info8/0ad967866b694b96852fd21529ea2b20.jpg)
![韩顺平Java学习 面向对象【高级】(笔记)_第22张图片](http://img.e-com-net.com/image/info8/c180561c9d4c42dc81a505e6635be0b8.jpg)
2-2:匿名内部类
同样在外部类的局部位置,但是没有类名
![韩顺平Java学习 面向对象【高级】(笔记)_第23张图片](http://img.e-com-net.com/image/info8/b53407148c2a416b85385c55255745b7.jpg)
Dog是普通方法;
Tiger是用匿名内部类的方法;
- /** AnonymousInnerClass(匿名 内部 类)
- * 演示
- */
- public class AnonymousInnerClass {
- public static void main(String[] args) {
- Outer04 outer04 = new Outer04();
- outer04.method();
- }
- }
- class Outer04 {
- private int n1 = 1;
- public void method() {
- dog dog1 = new dog();
- dog1.cry();
- //匿名内部类tiger1
- A tiger1 = new A() {
- @Override
- public void cry() {
- System.out.println("hu ku ");
- }
- };
- tiger1.cry();
- }
- }
- interface A {
- public void cry();
- }
- class dog implements A {
- @Override
- public void cry() {
- System.out.println("gou ku ");
- }
- }
匿名内部类使用细节
![韩顺平Java学习 面向对象【高级】(笔记)_第24张图片](http://img.e-com-net.com/image/info8/d72fece78e6c44e699814b5564b767ad.jpg)
![韩顺平Java学习 面向对象【高级】(笔记)_第25张图片](http://img.e-com-net.com/image/info8/d6a553c484c0478986242021e26b3c76.jpg)
可以把匿名内部类当做实参,来进行传递:
练习:
![韩顺平Java学习 面向对象【高级】(笔记)_第26张图片](http://img.e-com-net.com/image/info8/adb5e1479ea749ba91df1431c5af7960.jpg)
- public class AnonymousInnerClassExercise_2 {
- public static void main(String[] args) {
- Cellphone cellphone = new Cellphone();
- //匿名内部类当做实参
- cellphone.alarmclock(new Bell() {
- @Override
- public void ring() {
- System.out.println("pig getup");
- }
- });
- cellphone.alarmclock(new Bell() {
- @Override
- public void ring() {
- System.out.println("gays study");
- }
- });
- }
- }
- //铃声接口
- interface Bell{
- void ring();
- }
- class Cellphone{
- void alarmclock(Bell bell){
- bell.ring();
- }
- }
2-3成员内部类
说明:成员内部类是定义在外部类的成员位置,并且没有static修饰。
- 可以直接访问外部类的所有成员;
- 可以添加任意访问修饰符,因为它也相当于一个成员;
![韩顺平Java学习 面向对象【高级】(笔记)_第27张图片](http://img.e-com-net.com/image/info8/b2e8dfa7309a4e3283e00692dab4604a.jpg)
访问方法:
- public class MemberInnerClass_ {
- public static void main(String[] args) {
- Outer outer = new Outer();
- //第一种方式:
- //用外部类的对象,outer来new一个内部类Inner;
- Outer.Inner inner = outer.new Inner();
- //第二种,外部类中返回一个inner
- Outer.Inner inner = outer.getInner();
- }
- }
- class Outer{
- class Inner{ }
- //第二种,外部类中返回一个inner
- public Inner getInner(){
- return new Inner();
- }
- }
![](http://img.e-com-net.com/image/info8/3fbc46f0771d4d4e97704713ff57845b.jpg)
2-4静态内部类
![韩顺平Java学习 面向对象【高级】(笔记)_第28张图片](http://img.e-com-net.com/image/info8/e742268a7f1740b8b92615e702511b69.jpg)
![](http://img.e-com-net.com/image/info8/70482821662b427da74097a28d3345b4.jpg)
访问方法跟成员内部类相似;