第一次预习博客

蓝旭后端第一次培训预习博客

0.基本语法

输入输出：

package org.example;
import java.util.Scanner;//导包
public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in); //    创建对象                               int i=sc.nextInt();//接收数据
        System.out.println(i);//输出数据
    }
​
  
}

if语句：

package org.example;
public class Main{
     public static void main(String[] args){
     int number=20;
     if(number>=10){
     System.out.println("number>=10");
     }
     }
}

switch:

package org.example;
public class Main{
     public static void main(String[] args){
     int number=20;
     switch(number){
     case 10:
     System.out.println("number=10");
     break;
     case 20:
     System.out.println("number=20");
     break;
     defult:
      System.out.println("null");
     }
     }
}

数组：

package org.example;
public class Main{
     public static void main(String[] args){
     int arr1[]=new int[]{1,2,3};
     int arr2[]={33,324};
     String arr3[]=new String[]{"adasdaw","sadwaasd"};
      String arr4[]{"adasdaw","sadwaasd"};
      double arr1[]=new int[]{1.9,2.0,3.3};
     double arr2[]={33.6,324.54};
}
}

1.方法

类似于C语言中的函数

package org.example;
public class Main{
public static void main(String[] args){
myLife();                                      //调用
}
public static void myLife(){                   //开始定义
System.out.println("wow");                     //方法体
}
}

package org.example;
public class Main{
public static void main(String[] args){
myLife(11,22);                                      //调用
}
public static void myLife(int n1,int n2){  //开始定义
int resule=n1+n2;
System.out.println(result);                     //方法体
}
}

返回值调用方法

1.

int sum=myLife(1,2);
System.out.println(sum);

2.

System.out.println(myLife(1,2));

方法的重载

定义：同一个类中，方法名相同，参数不同

条件：同一个类，参数个数相同，参数类型相同

如

public class Main{
public static void main(int a){
}
public static void main(double a){
}
}
​

public class Main{
public static void main(int a){
}
public static int main(int a,int b){
}
}

public class Main{
public static void main(int a,double b){
}
public static int main(double a,int b){
}
}

两两构成重载

2.面向对象

三大特征：封装，继承，多态

定义类

public class Phone {
string brand;//属性，默认为null
double price;//默认值为0.0
public void call(){
System.out.println("call"); //行为
}
}

package org.example;
public class PhoneText{
public static void main(String[] args){
Phone p=new Phone();//创建手机的对象
p.brand="apple";
p.price=6666;//给手机赋值
System.out.println(p.brand);
System.out.println(p.price);//获取值
p.call();//调用方法
​
Phone p2=new Phone();
}
} 

Javabean类：不写main，描述一类对象

测试类：写main

3.封装

定义：封装对应的数据，提供对应的行为

private 关键字

public class GirlFriend{
private int age;
//set 赋值
public void setAge(int a){
if(a>=18&&a<=50){age=a;}
else{System.out.println("非法数据");}
​
public int getAge(){
return a;
public void call(){
System.out.println("call");
}
}

package org.example;
public class GirlFriendText{
public static void main(String[] args){
GirlFriend gf1=new GirlFriend();
gf1.setAge(18);
System.out.println(gf1.getAge());
p.call();
​
Phone p2=new Phone();
}
} 

就近原则

public class GirlFriend{
    private int age;//成员变量
    public void method(){
    int age=10;//局部变量
    System.out.println(age);//输出为10
    }
}

this语句

上述代码若想使用成员变量的值

改为System.out.println(this.age);//输出为0

使用this传递变量

public class GirlFriend{
    private int age;//成员变量
    public void setAge(int age){
    if(age>=18&&age<=50){this.age=age;}
else{System.out.println("非法数据");}
​
    }
    public int getAge(){return age;}
}

构造方法

定义：创建对象时给成员变量赋值

特点：1.方法名与类名完全相同

2.没有返回值类型，包括void

3.不能又return带回数据

package org.example;
public class Main{
    public static void main(String[] args){
        //Student s=new Student(); 空参构造
        Student s=new Student("zhangsan",23);//有参构造
        System.out.println(s.getName());
        System.out.println(s.getAge());
    }
}

package org.example;
public class Student{
   private String name;
   private int age;
        //public Student(){
        // System.out.println("执行了");
        //}
       public Student(String name,int age){
       this.name=name;
       this.age=age;
       }
    }
​

标准JavaBean

1.类名见名知意

2.成员变量private修饰

3.两种构造方法都用

4.每一个成员变量对应set/get

4.继承

关键字extends使两个类建立关系,把子类重复的代码抽到父类中

public class Student extends Person{}

Students为子类，Person为父类

java只支持单继承，a只能继承b，b还可以继承c，类似于树状图

子类只能访问父类非private成员

package org.example;
public class Animal{
  public void eat(){
  System.out.println("eat");
  }
    }

package org.example;
public class Gog extends Animal{//继承
  public void watchHome(){
  System.out.println("watch home");
  }
    }

package org.example;
public class Husky extends Dog{//继承
  public void destoryHome(){
  System.out.println("break home");
  }
    }

package org.example;
public class Main{
    public static void main(String[] args){
       Husky rd=new Husky();//创建husky对象
       rd.eat();
       rd.watchHome();
       rd.destoryHome()
    }
}

this.eat()优先在本类查看eat方法，若无，调用父类的eat方法

supre.eat直接调用父类的方法

重写

父类的方法不能满足子类的需求

重写方法的名称，形参列表要与父类一模一样

@Override:放在重写后的方法上面，校验子类重写使语法是否正确

@Override
 public void destoryHome(){
 System.out.println("watch home");
 }

私有方法和静态方法不能添加到虚方法表，不能被重写

多态

父类package org.example;
public class Person{
private String name;
    public Person(){
    
    }
    public Person(String name){
    this.name=name;
    }
  public void setName(String name){
  this.name=name;
  }
  public String getName(){
  return name;
  }
  public void show(){
  System.out.println("name");
  }
    }

子类
package org.example;
public class Student exends Pseson{
    @Override
    public void show(){              //重写
    System.out.println("Studentname");
    }
}

子类
package org.example;
public class Teacher exends Pseson{
    @Override
    public void show(){               //重写
    System.out.println("Teachername");
    }
}

package org.example;
public class Text{
    public static void Text(String[] args){
    Student s=new Student();
    s.setName("zhangsan");
    }
    Teacher t=new Teacher();
    t.setName=("wangjg");
    
    register(s);
    register(t);
    }
    public static void register(Person P){
    p.show();
    }
​

接口

public interface 接口名{}

public class 类名 extends 父类 implements 接口名1，接口名2

作者：王宇庆