Java语法+面向对象三大特征

一、Java语法

1、输入输出

输入基本型数据

1.使用Scanner类创建一个对象

Scanner reader = new Scanner(System.in);

2.reader对象调用下列方法，读取用户在命令行输入的各种基本类型数据：

nextBoolean(),nextByte(),nextShort(),nextInt(),nextLong(),nextFloat(),nextDouble()

import java.util.Scanner;
public class Example1{
    public static void main(String args[]){
        System.out.println("请输入若干个数，每输入一个数回车确认");
        System.out.println("最后输入数字0结束输入操作");
        Scanner reader = new Scanner(System.in);
        double sum = 0;
        double x = reader.nextDouble();
        while(x!=0){
            
            sum=sum+x;
            x= reader.nextDouble();
        }
        System.out.println("SUM="+sum);
    }
}

输出基本型数据

输出字符串常量时，不可以出现“回车”，可以将字符串分解成几部分，使用并置符号+将它们首尾相接 

1.  System.out.println("你好，很高兴认识你");输出数据后换行
2. System.out.print("你好，很高兴认识你");不换行
3. System.out.printf("格式控制部分",表达式1，表达式2);

2、数组

数组是相同类型的数据元素按顺序组成的一种复合数据类型，数组属于引用型变量，两个相同类型的数组如果具有相同的引用，它们就有完全相同的元素。

声明数组

声明一维数组

• 数组的元素类型 数组名[ ]; 
• 数组的元素类型 [ ] 数组名; 

声明二维数组

• 数组的元素类型 数组名[ ] [ ]; 
• 数组的元素类型 [ ] [ ] 数组名; 

int [ ] a,b[ ];是声明了一维数组a和二维数组b,等价的声明是：int a[ ],b[ ] [ ]; 

不允许在数组中的方括号内指定数组元素的个数。

为数组分配元素 

数组名 = new 数组元素的类型 [元素个数];

声明数组和创建数组可以一起完成，例如：float numebr = new float [4]; 

length的使用

对于一维数组，“数组名.length”的值是数组中元素的个数；

对于二维数组，“数组名.length”的值使它含有的一维数组的个数。 

3、分支

if

1. if语句 
2.  if-else语句
3.  if-else if-else语句

switch 

switch(表达式)

{

        case 常量值 1:

                        若干语句；

                         break;

        case 常量值 2:

                        若干语句；

                         break;

        case 常量值 n:

                        若干语句；

                         break;

        default:

                若干语句;

}

表达式的值可以为byte、short、int、char型；常量值也是byte、short、int、char型。

在switch语句中，通过合理的使用break语句，可以达到根据一个条件执行多个分支操作（多个case）的结果

4、循环

for

for(表达式1；表达式二；表达式3) {

        若干语句

}

（1）执行表达式1，初始化

（2）判断表达式2，若为true，则执行（3），否则进行（4）

（3） 执行循环体，计算表达式3,改变循环条件，进行（2）

（4）结束for语句

while

while（表达式）{

        若干语句

} 

（1）若表达式的值为true，进行（2），否则执行（3）

（2）执行循环体，进行（1）

（3）结束while语句 

do-while

do{

        若干语句

}while(表达式)；

do-while循环和while循环的区别是do-while循环的循环体至少被执行一次。 

二、面向对象三大特征

1、封装

将数据和对数据的操作封装在一起。

1. public（公共权限）：

• 任何类都可以访问public修饰的变量或方法。
• 它允许所有用户直接调用该数据成员或成员函数。
• public的公有性意味着它具有最大的开放性和灵活性，但同时也可能带来安全风险，因为任何外部类都可以修改其值。

      2.private（私有权限）：

• private修饰的变量或方法只能被当前类访问，任何其他类（包括子类）都无法直接访问。
• 它提供了最严格的数据封装，有助于隐藏对象的内部状态和实现细节，仅对外提供必要的接口。
• 虽然private修饰的成员变量或方法不能直接被外部类访问，但可以通过当前类提供的公共方法进行间接访问和操作。

      3.protected（受保护权限）：

• protected修饰的变量或方法不仅可以在当前类中被访问，还可以在子类中被访问。
• 它提供了介于public和private之间的访问级别，允许子类继承父类的某些属性和方法，同时仍然保持一定的封装性。
• protected的访问权限仅限于通过派生类类型进行访问，即只有在继承关系中，基类的受保护成员在派生类中才是可访问的。

2、继承

子类可以继承父类的属性和行为，既继承父类所具有的数据和数据上的操作，同时又增添子类独有的数据和数据上的操作。

关键字extends,可以让一个类和另一个类建立起继承关系

public class Students extends Person { }

Student称为子类（派生类），Person称为父类（基类或超类） 。

特点 

•  Java只支持单继承（一个类只能继承一个父类），不支持多继承，但支持多层承继。
• 每一类都直接或间接继承于Object类。
• 子类只能访问父类中非私有的成员

 继承内容

• 能继承：成员变量、非私有成员方法
• 不能继承：构造方法（但是可以通过super调用）、private成员方法

访问特点

• 成员变量  就近原则

System.out.println(name);        从局部位置开始往上找

System.out.println(this.name);        从本类成员位置开始往上找

System.out.println(super.name);        从父类成员位置开始往上找

•  成员方法 

this调用：就近原则

super调用：直接找父类 

 方法的重写  ：当父类的方法不能满足之类现在的需求时，需要进行方法重写（@Override重写注释），重写方法的名称、形参列表必须与父类一致

• 构造方法 

子类中所有的构造方法默认先访问父类中的无参构造，子类初始化之前，一定要调用父类构造方法先完成父类数据空间的初始化，子类构造方法的第一句默认都是super(),不写也存在，且必须在第一行，如果想调用父类有参构造，必须手动写super进行调用。 

3、多态

多态 

 多态的表现形式

父类类型 对象名称 = 子类对象；

多态的前提

• 有继承/实现关系
• 有父类引用指向子类对象
• 有方法的重写  

优势 

1. 使用父类型作为参数，可以接收所有子类对象   
2. 在多态形势下，右边对象可以实现解耦合，便于扩展和维护

Person p = new Student ();

p.work(); //new Student处发生变化时，后续代码无需更改 

弊端 

不能使用子类的特有功能，需要进行强制类型转换，转化为真正的子类类型

自动类型转换          Person p = new Student ();

强制类型转换          Studnet s =(Student) p;

接口 

• 接口用关键字Interface来定义,不能实例化（不能创建对象，没有构造方法）

public interface 接口名 {} 

• 接口和类之间是实现关系，通过implements关键字表示，可以单实现也可以多实现 

public class 类名 implements 接口名 {}

public class 类名 implements 接口名1，接口名2 {}

public class 类名 extends 父类 implements 接口名1，接口名2 {} //实现类（接口的子类）还可以在继承一个类的同时实现多个接口

接口成员变量 ： 只能是常量， 默认修饰符 ：public static final

•  接口和接口的关系：继承关系，可以单继承，也可以多继承（若实现类实现了最下面的子接口，需要重写所有的抽象方法）

 public interface Inter3 extends Inter1,Inter2{

         public abstract void method();

} 

重载 

一个类中可以有多个方法具有相同的名字，但这些方法的参数必须不同（个数不同或参数列表中对应某个参数类型不同）

class People{
    float hello(int a,int b)
    {
        return a+b;
    }
    float hello(long a, int b)
    {
        return a-b;
    }
    double hello(double a,int b)
    {
        return a*b;
    }
    
}
public class Example2{
    public static void main(String args[]){
        People tom = new People();
        System.out.println(tom.hello(10,20));
        System.out.println(tom.hello(10L,20));
        System.out.println(tom.hello(10.0,20));
    }
}