第一天：java基础复习（1）

一、概述

        编程就是让计算机为解决某个问题而使用某种程序设计语言编写程序代码，并最终得到结果的过程。

        Java是一门面向对象的编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。

二、基础语法

1、标识符

        java 中用来给变量、方法、类、接口等命名的名称 称为标识符。

        标识符的命名规则：

        (1)、包名：所有字母一律小写。如：com.abc.demo。

        (2)、类名和接口名：每个单词的首字母大写，其余小写。如：StudentDemo,HelloWorld。

        (3)、常量名：所有字母都大写，单词间以下划线(_)连接。如：DAY_OF_MONTH。

        (4)、变量名和方法名：第一个单词首字母小写，从第二个单词开始每个单词首字母大写。即驼峰式命名法。如：chineseScore,getTotalMoney()。

        (5)、在程序中，应尽量使用有意义的英文单词来定义标识符，即见名知义，这样便于阅读。如：password表示密码，name表示姓名等

2、关键字

        java 中赋以特定的含义的，有专门用途的字符串称为关键字；并且java中所有的关键字都是小写；

3、注释

        单行注释：使用//来进行注释；

       多行注释：使用/* 和*/注释界定符将一段比较常的注释括起来；

        文档注释：以/** 开始，以 */ 结束，这种注释可以用来自动生成文档

4、基础数据类型

整数类型：

        byte、short、int、long

浮点类型：

        float、double

字符类型：

        char 类型原本是用于表示单个字符

布尔类型：

        boolean 只有两个值 false 和 true，用来判定逻辑条件

5、常量与变量

        常量就是值不变的变量，用final关键字修饰；

        根据使用随时改变的量叫变量；

6、运算符

算数运算符：

        （+ - * / %）加 减 乘 除 取模

逻辑运算符：

        （ 与 - && 、或 - ||、非 - ！）

位运算符：

        （ >> 、 << 、>>> )有符号右移、有符号左移、无符号右移

7、控制流程

选择结构：

        if 单选择结构

        if - else 双选择结构

        if - else if - else 多选择结构

分支结构：

        while：尽量避免死循环

        do... while

        break（跳出循环） & continue（终止当此循环，继续下次循环）&return（结束方法的运行）

三、面向对象（三大特性）

封装：

        封装：隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互

访问修饰符：

总结: private 声明的属性需要生成public的get，set方法来从外部调用(方法也需要)

继承：

        继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力；俗称子类继承父类。

        关键字：extends

        格式：class 子类 extends 父类{ }

        java只支持单继承，一个子类只能继承一个父类，但是可以多重继承

class A{
	
}
// 父类
class B extends A{
	
}
//多重继承   孙子类
class C extends B{
 
}

多态:

        多态：一个对象拥有多种形态，是面向对象的三大特性之一，多态建立在封装和继承之上；父类引用指向子类对象

        格式：
        父类名称 对象名 = new 子类名称( );
        接口名称 对象名 = new 实现类名称( );

        多态的转型：

        向上转型：父类的引用指向子类的对象（子类到父类）

        向下转型：当父类型的引用想访问子类型中特有的方法的时候，此时就必须进行向下转型（父类到子类）

 Animal bird = new Bird()；//向上转型

Cat x = (Cat)bird ; //向下转型

好处：

        1. 消除类型之间的耦合关系

        2. 可替换性

        3. 可扩充性

        4. 接口性

        5. 灵活性

        6. 简化性

四、类与接口

抽象类：

定义：

        抽象类是指在普通类的结构里面增加抽象方法的组成部分。在Java中一个没有方法体的方法被定义为抽象方法，如果一个类中有抽象方法，那么这个类必须定义为抽象类。

特性：

        使用abstract修饰的方法,叫做抽象方法。

        抽象类和抽象方法必须有"abstract"关键字修饰；

        抽象类中不一定只有抽象方法，有抽象方法的类一定是抽象类；

        抽象类是不能进行实例化的；

        抽象类当中,可以有和普通类一样的方法,成员.构造方法. 和普通类不一样的最突出地方就是抽象类不可以实例化；

        抽象类可以被继承；

        抽象方法不能被private, static, final 修饰.因为抽象方法要被子类重写

优点：

        封装不变部分，扩展可变部分

        提取公共代码，便于维护

        行为由父类控制，子类实现

使用：

public abstract class Employee
{
   private String name;
   private String address;
   private int number;
   
   public abstract double computePay();
   
   //其余代码
}

public class Salary extends Employee
{
   private double salary; // Annual salary
  
   public double computePay()
   {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
 
   //其余代码
}

接口：

定义：

        接口声明了一组能力，但它自己并没有实现这个能力，它只是一个约定；

特性：

        接口中的变量可以定义变量（public static final int a = 0）；

        一个接口可以继承其他接口，继承的基本概念与类一样，但与类不同的是，接口可以有多个父接口（public interface IChild extends IBase1,IBase2{}）

        类可以在继承基类的情况下，同时实现一个或多个接口（class Child extends Base implements IChild()）

实现：

        类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用 implements 关键字。

public interface MyComparable{
        int comparTo(Object other);
}

public class Point implements MyComparable {
    private int x;
    private int y;
    public Point(int x,int y){
        this.x = x;
        this.y = y;
    }
    public double distance(){
        return Math.sqrt(x*y+y*y);
    }
 
    @Override
    public String toString() {
        return "{"+x+", " +y+"}";
    }
 
    @Override
    public int comparTo(Object other) {
        if(!(other instanceof Point)){
            throw new IllegalArgumentException();
        }
        Point otherPoint = (Point)other;
        double delta = distance() - otherPoint.distance();
        if(delta <0){
            return -1;
        }else if (delta > 0 ){
            return 1;
        }else {
            return 0;
        }
    }
}

使用：

        与类不同，接口不能直接new出一个接口对象，对象只能通过类来创建。但可以声明接口类型的变量，引用实现了接口对象的类

        MyComparable P1 = new PoInt(2,3);

        Mycomparable p2 = new PoInt(1,2);

        system.out.print( p1.compareTo(p2))

public interface LiveAble {
    // 定义抽象方法
    public abstract void eat();
    public abstract void sleep();
}

public class Animal implements LiveAble {
    @Override
    public void eat() {
        System.out.println("吃东西");
    }
    @Override
    public void sleep() {
        System.out.println("睡觉");
    }
}

public class InterfaceDemo {
    public static void main(String[] args) {
        // 创建子类对象
        Animal a = new Animal();
        // 调用实现后的方法
        a.eat();
        a.sleep();
    }
}

区别：

        

 

五、变量与方法

成员变量：

        在方法体外，类体内声明的变量称为成员变量

局部变量：

        在方法体当中声明的变量以及方法的每一个参数都是局部变量；

静态变量：

        成员变量声明时如果使用static关键字修饰的为静态成员变量（简称静态变量）

实例变量：

        如果没有 static 关键字修饰则称为实例成员变量（简称实例变量）

public class VarTest {
	int x1; // 实例变量，声明时可以不用赋值，有默认值
	int x2 = 10; // 实例变量
	static int y1 = 20; // 静态变量，声明时可以不用赋值，有默认值
	public static void sum(int a, int b){ // 局部变量 a 和 b
		int num = 100; // 局部变量，声明时必须赋值
	} 
}

构造方法：

作用：

        构造方法是用来创建对象，并且同时给对象的属性赋值（如果没手动赋值，系统会自动赋值）

语法：

        [修饰符列表] 构造方法名(形式参数列表){

                构造方法体; 通常在构造方法体当中给属性赋值，完成属性的初始化。

         }

        修饰符统一为public；构造方法名必须和类名相同；不需要指定返回值类型，也不写void；

        调用：new 构造方法名(实际参数列表);

无参构造方法：

        构造方法中没有参数，就说明他就是一个默认构造方法，也称为无参构造方法；无参构造函数类中只定义一个方法。构造器总是伴随着new操作一起调用. new对象时，就调用与之对应的构造函数，执行这个方法。不必写“.方法名”

class Confun{        
    Confun(){        
        //定义构造函数，输出Hello World
        System.out.println("Hellow World");
    }
}

有参构造方法：      

        有参数的构造方法；有参构造的作用，可以在创建对象的时候直接赋予值

class PersonDemo{
    private String name;
    private int age;
    PersonDemo(String n,int m){   //建立有参构造函数，用于给变量name、age赋值，同时输出值
        name=n;
        age=m;
        System.out.println("姓名："+name+"\n"+"年龄："+age);
    }
 
}

当一个类中没有定义构造函数时，系统会给该类中加一个默认的空参数的构造函数，方便该类初始化。只是该空构造函数是隐藏不见的；当在该类中自定义了构造函数，默认构造函数就没有了

构造函数的使用：

        子类所有的 构造函数 默认调用父类的无参构造函数（构造函数不会被继承，只是被子类调用而已），父类参数是private的，无法直接访问

        使用super调用父类的构造函数