• Java--面向对象


    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修饰符,系统也会加速上

  • 相关阅读:
    5. support vector machine
    机器学习实战(二)决策树
    机器学习实战(一)kNN
    深度学习笔记(无)VGG14
    深度学习笔记(一)线性分类器(基础知识)
    Eclipse代码风格
    windows安装java环境
    linux matlab2013b 安装教程
    小白Linux入门 五
    机器学习 0
  • 原文地址:https://www.cnblogs.com/Nyan-Workflow-FC/p/6393907.html
Copyright © 2020-2023  润新知