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

是赵敢敢啊

已于 2022-03-07 16:54:10 修改

阅读量161

点赞数

分类专栏： java 文章标签： java

于 2022-03-07 16:52:25 首次发布

本文链接：https://blog.csdn.net/qq_42059717/article/details/123334209

版权

java 专栏收录该内容

65 篇文章 2 订阅

订阅专栏

第六章面向对象编程下

1.关键字 static

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

1.1 static 修饰属性

static 修饰的变量也称为静态变量

按照是否使用static修饰可以分为

静态变量(类变量) vs 非静态变量(实例变量)

非静态变量：创建了类的多个对象，每个对象都独立的拥有一套类的非静态属性，改变其中一个对象的非静态属性时，不会导致其他对象同样的属性修改。

静态变量：创建了类的多个对象，多个对象共享一个静态变量，当通过一个对象修改静态变量的值的时候，其他对象调用此变量是，是修改过的。
static修饰的属性

静态变量随着类的加载而加载，可以直接通过类.静态变量的方法调用
静态变量的加载早于对象的加载
由于类只会加载一次，所以静态变量在内存中也只会有一份，存在于方法区的静态域中

举例
```
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修饰的方法叫静态方法

随着类的加载而加载，可以通过类.静态方法的方式进行调用

	静态方法	非静态方法
类	yes	no
对象	yes	yes

静态方法中只能调用静态的方法或属性

非静态方法中，既可以调用非静态的方法。也可以调用静态的方法。

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

    }
}

**static注意点 **

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

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

属性

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

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

操作静态属性的方法，通常设置为静态的

工具类中的方法，通常定义为static的，如Math，Arrarys。

2.main方法的语法

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

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

用来初始化类，对象

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

4.关键字 final

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

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

5. 抽象类与抽象方法

抽象类

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

抽象类也是类，也有构造方法，但是不可以用来创建对象，是给子类构造器首行的super()调用的
抽象方法表示这个类型一定会这个方法，但是现在给不出来具体的实现，待留给子类去实现当一个类中出现了抽象方法以后，这个类一定变成抽象方法，
```
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接口和抽象类之间的区别

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

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

接口里边定义的属性都是静态的**[public static final]**
里边定义的方法不一样

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

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

6.2 接口的应用

代理模式

工厂模式
- 简单工厂模式

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. 单例模式

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

实现单例模式

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

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修饰即可
饿汉式	饿汉式是线程安全的	对象加载时间过长