蓝旭后端第一次培训预习博客
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
作者:王宇庆