Java基础知识复习

控制流程

1.顺序结构

2.分支结构

if…else switch…case

3.循环结构

for（foreach） while do…while

int[] arr= new int []{1,3,0,9,1};

for(int i =0;i<arr.length-1;i++){
    System.out.println(arr[i]);
}

int i=0;
while(i<arr.length-1){
    System.out.println(arr[i]);
    i++;
}

//

数组

//某一门课的成绩
double zhangsan=90.5
double lisi=99;
//..多个变量维护比较麻烦

产生的原因----多个相同数据类型的变量存储

一、定义

int[] a;
//int a[];

二、初始化

1.静态初始化

int[] arr=new int[]{1, 3, 5, 0}
//int[] arr ={};
//给定值让系统决定长度

2.动态初始化

int[] arr=new int[5];


//给定长度让系统决定值

byte、short、int、long–0

double、float----0

char------编码表对应‘0’的值，控制台无法打印出来

boolean----false

引用----null

数组中既可以存放基本数据类型变量，也可以存放引用数据类型变量（数组中也可以存放对象）

三、下标

0–数组长度-1

数组的长度 数组名.length

如何访问数组中特定的元素

数组名[下标]

四、常见操作

遍历

​ 普通for循环

​ while循环

​ 增强for

排序（冒泡、选择、快速）

求最值

逆序

五、多维数组—二维数组

方法 函数

y=f(x)

int add(int a,int b){
    return a+b;
}

一、定义

返回值类型 方法名（参数列表）{

​ //方法体

​ //return 返回值；

}

二、方法的重载

同一个类当中，方法名相同，参数列表不同

三、方法的重写

子类对父类的继承

方法名相同、参数列表相同、返回值类型相同、方法体不同

面向对象

1.面向对象和面向过程

面向对象-----对象-----主体

Person p =new Person();
p.eat("汉堡");

面向过程—过程—做什么事

void eat(Person p,Rice r);

2.类和对象

String name;
int age;
int height;
String address;
int gender;

8种基本数据类型不能满足定义变量的要求---->自定义类型------->类 （生产汽车的图纸）

对象—实体----真正存在的东西------>真正的汽车

3.如何定义类

一个类生产一个.class文件

[修饰符] class 类名{

​ //属性—成员变量

​ //构造方法

​ //普通方法—成员方法、成员函数

}

如何创建对象

Class Person{
String name;
int age;
int height;
String address;
int gender;
    void eat(){
        System.out.println("eat.....");
    }
}
Person p=new Person();

4.构造方法

在创建对象的时候被调用，给属性赋值(初始值)

-1)定义类时没有定义构造方法，那么类中存在默认的构造方法

​ Preson(){

​ }

-2)如果自定义了构造方法，那么默认的构造方法会被覆盖；如果此时希望使用默认的构造方法，需要自己手动定义

Class Person{
String name;
int age;
int gender;
    //默认的构造方法
    Person(){
        
    }
    //带参数的构造方法
    Person(String name, int age){
    	this.name=name;
        this.age=age;
    }
    
    void eat(){
        System.out.println("eat.....");
    }
}

Person p =new Person();//调用默认的构造方法

5.封装

隐藏该因此的，暴露该暴露的

1.把属性设置成private的，设置相应get/set方法

2.方法一般设置成public的

Class Person{
	private String name;
	private int age;
	private int gender;//性别
    //默认的构造方法
    Person(){
        
    }
    
    Person(String name){
        this.name=name;
    }
    
    //带参数的构造方法
    Person(String name, int age){
        //构造方法
        this(name);
     
        this.age=age;
    }
    
    public String getName(){
        //this代表的是当前调用这个方法的对象
        return this.name;
    }
    
    void eat(){
        System.out.println("eat.....");
    }
}

Person p =new Person();
System.out.println(p.getName())

6.继承----extends----扩展

1.只能有有一个直接父类，间接父类可以有n个

2.方法的重写

3.super表示父类的对象，表示父类的构造方法

​ this表示当前类的对象，表示当前类的构造方法

class Student extends Person{
    private String stuId;
    
    public void study(){
        System.out.println("我的心里只有学习")
    }
    
    public void eat(){
        System.out.println("student eat....")
    }
}

7.多态

1.方法的重写和重载

2.子类对象的多态性

//等号的左边  左侧 p---引用     等号右边  右侧  真正的对象
Person p =new Student();//子类对象赋值给父类的引用
/*
    编译期间看左侧

*/
p.study()//不能编译通过
p.eat()//能编译通过  输出 student eat....
//运行期间看右侧

3.优势

class Test{
/*	public void test(int a){
    
	}
    public void test(char a){
        
    }
    public void test(String s){
        
    }
    public void test(Person p){
        
    }
    */
    /*
      Object类是所有类的父类
      Person p =new Person();
      Object o =p;
      test(p);
    */
    public void test(Object o){
        //instanceof(运算符)判断传进来的数据类型
    }
}

8.抽象类和接口