0
点赞
收藏
分享

微信扫一扫

Java编程基础六:面向对象编程下


第六章 面向对象编程 下

1.关键字 static

  • static 可以用来修饰属性,方法,代码块,内部类

1.1 static 修饰属性

  • static 修饰的变量也称为静态变量
  1. 按照是否使用static修饰可以分为
    静态变量(类变量) vs 非静态变量(实例变量)
    非静态变量:创建了类的多个对象,每个对象都独立的拥有一套类的非静态属性,改变其中一个对象的非静态属性时,不会导致其他对象同样的属性修改。
    静态变量:创建了类的多个对象,多个对象共享一个静态变量,当通过一个对象修改静态变量的值的时候,其他对象调用此变量是,是修改过的。
  2. static修饰的属性
  • 静态变量随着类的加载而加载,可以直接通过类.静态变量的方法调用
  • 静态变量的加载早于对象的加载
  • 由于类只会加载一次,所以静态变量在内存中也只会有一份,存在于方法区的静态域中
  1. 举例

System.out
Math.PI;

类变量

实例变量

可以调用

不可以调用

对象

可以调用

可以调用

public class StaticTest1{
    public static void main(String[] args){
		Chinese c1 = new Chinese();
        c1.name = "张三";
        c1.age = 20;
        
        Chinese c2 = new Chinese();
        c2.name = "李四";
        c2.age = 45;
        c2.nation = "CHN";
        System.out.println(c1.nation);
    }
}
class Chinese{
    String name;
    int age;
    static String nation ;
}

1.2 static修饰方法-

  • static修饰的方法叫静态方法
  1. 随着类的加载而加载,可以通过类.静态方法的方式进行调用

静态方法

非静态方法

yes

no

对象

yes

yes

  1. 静态方法中只能调用静态的方法或属性
    非静态方法中,既可以调用非静态的方法。也可以调用静态的方法。

public class StaticTest2{
    publiv static void main(String[] args){

    }
}

**static注意点 **

  1. 在静态方法内,不能使用this关键字和super关键字

1.3 如何确定属性或方法要不要声明成静态的

  1. 属性

属性可以被多个对象所共享的,不会随着对象的变化而变化的

类中的常量通常定义为static的

  1. 方法
    操作静态属性的方法,通常设置为静态的
    工具类中的方法,通常定义为static的,如Math,Arrarys。

2.main方法的语法

  1. main()方法是程序的入口
  2. main()方法也是一个普通的静态方法
  3. main()方法可以作为跟控制台交互的方式

3.类的成员之四:代码块

用来初始化类,对象

如果要用修饰符修饰的话只能用static

4.关键字 final

final修饰的类不可以有子类,但是可以有父类,final修饰的方法不可以被覆盖,但是可以被继承,当final修饰变量的时候,一旦赋值之后就不可以更改

final修饰属性时,保护的是属性的值不受改变,当final修饰的是引用数据类型时,保护的是引用的地址不发生改变

5. 抽象类与抽象方法

  1. 抽象类
    抽象类表示这个类不形象不具体,特点是不允许创建对象

抽象类也是类,也有构造方法,但是不可以用来创建对象,是给子类构造器首行的super()调用的

  1. 抽象方法表示这个类型一定会这个方法,但是现在给不出来具体的实现,待留给子类去实现当一个类中出现了抽象方法以后,这个类一定变成抽象方法,

public abstract Animal{
    //抽象方法的特点是不能有方法体,直接()结束
    public abstract void eat();
}

抽象方法里边既可以出现抽象方法又可以出现普通方法

6. 接口(interface)

  • 接口相当于工业生产中的规范
  • 接口不允许创建对象但是可以用匿名实现类

class、interface、enum、@interface在编译之后都

可以生成class文件

//如何定义一个接口
interface XXX{
    //属性
    //接口默认加上三个修饰符
    //public static final
    int x = 34;
    
    //方法:返回类型 +方法签名
    //接口默认加上两个修饰符
    //public abstract
    void show();
}

两两之间的关系

类和类之间:extends

类和接口之间:implements

接口和就扣之间:extends

java中的类只允许单根继承,但是接口允许多重继承,一个类在继承另外一个类的同时还可以实现多个接口

6.1接口和抽象类之间的区别

  1. 是java中的两个类型,抽象类属于类是class,接口是interface
  2. 里边边定义的属性不一样

抽象类里边定义的属性就是普通属性,最多加上一个default,

接口里边定义的属性都是静态的**[public static final]**

  1. 里边定义的方法不一样

抽象类里边既可以定义抽象方法,又可以定义普通方法

接口里边只能定义抽象方法从jdk8.0开始可以出现普通方法了

6.2 接口的应用

  1. 代理模式
  1. 工厂模式
  • 简单工厂模式

7.类的成员之五:内部类

  • java中允许把一个类声明在另外一个类中

class Person{
    static class Phone{
        
    }
    
    class PC{}
}
// Person.Phnone p = new Person.Phone();
//Person p = new Person();
//Person.PC p1 = p.new PC();

在局部内部类的方法中(show),如果调用局部内部类所声明的方法(method)的局部变量(num),要求变量必须声明成final的

public class Test{
    pubilc void method(){
        //JDK 7及以前需要显示的声明为final的 8及以后则不需要
        final int num = 1;
        class AA{
            public void show(){
                System.out.println(num);
            }
        }
    }
}

7.1 成员内部类

如果成员内部类不是静态的,那么内部类中也不能出现静态的属性或方法

7.4 匿名内部类

匿名内部类创建对象:

new 父类/接口(参数){

抽象方法的具体实现

}

8. 单例模式

  • 在某一个类中只能存在一个对象实例

实现单例模式

  1. 私有化构造器避免在其他类调用构造器
  2. 内部创建静态的类的对象
  3. 提供静态的公共的方法,返回类的对象

8.1 懒汉模式

//懒汉式
public class Singleton1{
    public static void main(String[] args){
       Order order1 = Order.getInstance();
       Order order2 = Order.getInstance();
       Order1 == Order2;//true
    }
}
class Order{
    //1.私有化构造器
    private Order();
    //2.声明当前类的对象,没有初始化
    //4.此对象也必须声明为静态的(static)
    private static Order instance = null;
    //3.声明公共的静态的返回当前对象的方法
    publicstatic synchronized Order getInstance(){
       if(instance == null){
           instance = new Order();
       } 
        return instance;
    }
}

8.2 饿汉模式

//饿汉式
public class Singleton{
    public static void main(String[] args){
        Bank bank1 = Bank.getInstance();
        Bank bank2 = Bank.getInstance();
        bank1 == bank2;//true
    }
}
class Bank{
    //私有化构造器
    private Bank();
    //内部创建类的将静态对象
	private static Bank instance = new Bank();
    //提供公共的静态方法,返回类的对象
    public static Bank getInstance(){
        return instance;
    }
}

好处

坏处

懒汉式

延迟对象创建

目前的写法是线程不安全的,用synchronized修饰即可

饿汉式

饿汉式是线程安全的

对象加载时间过长


举报

相关推荐

0 条评论