Java基础入门语法

最新推荐文章于 2024-05-05 13:57:09 发布

༒^O^

最新推荐文章于 2024-05-05 13:57:09 发布

阅读量122

点赞数 1

文章标签： java

本文链接：https://blog.csdn.net/Zero_xj/article/details/107514666

版权

1. Java命名
方法名，属性名，变量名使用驼峰命名法，见名知道意思
2. 基础定义
* 标识符:区分大小写，字母和下划线和美元符号和数字组成
* 关键字：
* 变量定义：数据类型变量名=变量值；

	int a=12;
	int b,c;
	b=12;
	c=0;
	System.out.println("shuchu"+a+b+c);

3. 键盘获取数据

 //创建一个Scanner的对象
Scanner input=new Scanner(System.in);
System.out.println("请输入数据：");
//通过input对象调用next方法，获取字符串
String str=input.next();
System.out.println("获取数据："+str);
//获取从键盘上的数字整形用nextInt();
int num=input.nextInt();

4. 流程控制
顺序结构

选择结构：

       1.if（条件）{
              执行语句；
              }
        
        if（条件）{
             执行语句1；
         }else{
              执行语句2；
         }
         2.switch(表达式){
             case 值1:
                  语句体1;
                  break;
              case 值2:
                   语句体2;
                   break;
                  ...
              default:
                   语句体n+1;
                   break; 
         }
          表达式值为：byte,short,int,char,枚举，String;
          表达式值和case上比较的值数据类型保持一致；

循环结构:初始化语句，判断条件，循环体语句，控制条件语句

         1.for(初始值;判断条件;步长）{
                循环体;
           }
         2.do{
             循环体；
             控制条件;
           }while(判断条件);//不管条件是否满足都会执行一次
         


         break:1.switch控制case后语句的结束；
               2.用于结束循环结构 （单层循环）    
               多层循环：break+标签；如break ok;
         continue:跳过本次循环执行下次循环；
         return：用于程序结束并返回到调用位置

5. 类和对象
类和对象：类是对象的模板，对象是具体的；
类的创建：

  修饰符  class(关键字) 类名{
     属性;
    行为方法(完成特定功能的代码块);
    }

对象的创建：new 对象名();

   public class People{
          private String name;
          private int age;
    }
    People p1 = new People();

方法的定义：
修饰符返回值类型方法名(方法形参1，…形参n){
方法体;
return 返回值;
}

public int methodName(String name){
     System.out.println("有参数有返回值");
     return 8;
}

方法的调用：
1.同类方法可以相互调用；不同类要创建对象来调用；
2.主方法中要通过对象（对象名.方法名）；

6. 抽象类

没有具体方法体的方法就是抽象方法，类含抽象方法就定义为抽象类；
抽象类：abstract class 类名{}
抽象类不能实例化
抽象方法：public abstract void 名();
abstract不能和private\final\static共存
抽象类的子类要么是抽象类，要么重写抽象类中的所有抽象方法

public abstract class Chouxiang {
	
	public abstract void method();
	
	public /*private*/ abstract void method2();

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

}
7. 数组

数组定义：数据类型[] 数组名；
数据类型数组名[]；
数组初始化：
动态- 数据类型数组名 = new 数据类型[数据长度];
int[] arr = new int[3];
静态-数据类型数组名 = new 数据类型[]{元素};
int[] arr={1,2,3};

public static void main(String[] args) {
	int[] arr;
	int arr1[];
	
	arr=new int[3];
	arr1=new int[] {1,2,3};
	int[] arr2=new int[]{4,5,6};
}

8. 集合

集合是为了方便存储和操作数目不固定的一组数据；
集合不能存放基本数据类型能存放对象；
类型：
list(列表)
Set(集)
Map(映射)

9. 方法重载

方法重载：
在同一个类下面方法名相同，
方法的参数个数、类型、排列顺序不同的多个同名方法;
与返回值无关；

public class MethotChongzai {
	
	public void method1() {
		
	}
	public int method1(int num) {
		System.out.println("有参数的方法"+num);
		return 8;
	}
	public void method1(int num,String name) {
		System.out.println("有两个参数的方法"+num+name);
	}
			
	public static void main(String[] args) {
		
		MethotChongzai me = new MethotChongzai();
		System.out.println(me);
		}

}

10. 构造器

构造器的作用：主要初始化对象
定义：
修饰符构造器名(参数){
构造方法体;
}

注意：
构造器名和类名相同，没有返回类型，也没有明确返回值
若不提供构造器则系统默认无参的构造器；
若自己提供，则系统不在提供默认无参的构造器；

public class gouzaoqi {
	public gouzaoqi(String name) {
		System.out.println("这是一个构造器"+name);
		
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		gouzaoqi c = new gouzaoqi("zhan");
	}

}

11. 接口

接口：interface 接口名{}
使用接口要用implements
接口不能实例化；
接口里方法只有声明没有实现；
一个类实现一个接口就实现接口里的所有方法，否则就是就是抽象类；
接口中的变量都只能是常量；
接口没有构造方法；
一个类可以实现多个接口；
一个接口可以继承多个其他接口；
权限修饰符：public,protected,默认，private;

public interface JieKou {
	
	public static final int num=34;
	
	/*public abstract */void method(){
		System.out.println("抽象方法");
	}
	
	public static void method2() {
		System.out.println("静态方法");
	}
	
	default void method3() {
		System.out.println("默认方法");
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

}

12. 封装与继承

  封装：是指隐藏对象的属性和访问细节，仅仅对外提供公共的访问方式；
  封装原则：把不需要对外提供的内容隐藏起来，提供公共访问方法
   private表示私有的，只能本类访问；  
   Java继承：
   		class 子类  extends 父类{
            }
    Java是单继承；
    一个类只可以一个继承，但是可以多层继承，
    不能继承父类的私有元素；
    super用于调用父类的变量方法等；
      
    方法重写：在继承关系的两类中，子类出现和父类一样的方法申明，即方法重写或方法覆盖
    使用特点：
    		1.如果方法名不同就调用对象的方法；
   		    2.如果方法名相同，最终使用的是子类的方法；
    应用：当子类需要对父类的功能，而功能主体子类有自己特有内容；
    注意：1.父类中私有方法不能被重写；
        2.子类重写父类方法时，访问权限不能更低；
   		（比如：父类方法是public，则子类重写不能是private)
    		3.父类静态方法，子类也必须通过静态方法重写；

例子：父类

public class People {
	 //属性或成员变量
   	 private int id;
   	 private float uname;
 	 private String num;
 	 public int rank = 10;
 	 //无参构造器
 	 public People() {	 
 	 }
 	 //有参构造器
 	 public People(String num,int id) {
 		 this.num = num;
 		 this.id = id;
 	 }
 	 
 	 public void method1() {
 		 String num ="123";//局部变量，必须初始化
 		 System.out.println("这是第一个方法"+num);//调用就近原则；
 		 System.out.println("这是第一个方法"+this.num);//调用属性num，
 	 }
 	 public void method2() {
 	 	String num ="号码";
 	 	System.out.println("这是第2个方法"+num+this.num); 	 
 				
 	 }

public static void main(String[] args) {
		// 创建对象调用值
        People p1 = new People();
        p1.id=10;
        System.out.println(p1.id);
        
        // 创建对象调用无参方法
        People p2 = new People();
        p2.method1();
        // 创建对象调用有参方法
        People p3 = new People();
        p3.method2();
        // 创建对象并初始化
        People p4 = new People("123",1);
        p4.method2();
        
	}

子类

public class Student extends People {
	public int rank=20;
	
	public void study() {
		System.out.println("学习"+super.rank);//父类的rank
		
	}
	public void method1() {//方法重写
		super.method1();	//通过super调用父类方法
		 System.out.println("方法重新二");
	 }
	public static void main(String[] args) {
		Student s = new Student();
		s.method1();
		s.study();
		System.out.println(s.rank);//子类的rank
	}

13. 静态Static

static:
1.修饰静态代码块；
2.修饰成员变量和成员方法；
特点：
随着类加载而加载；
优先于对象重载；
被类的所有对象共享；
其生命周期和类一致；
对于静态的变量和方法通过类名进行调用；
注意：静态变量可以通过类名或者对象名调用；
静态方法只能访问静态的成员变量和静态的成员方法；
在静态方法中不能使用this和super；
静态的内容存在于方法区的静态区；
静态变量和成员变量的区别：

public class StaticDemo {
    public static int id;
    static {
    	//静态代码块
    	System.out.println("静态代码快");
    }
    public static void method() {
    	System.out.println("静态方法");
    }
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		StaticDemo.method();
	}

}

14. final

final表示最终，主要用来修饰类、成员变量、成员方法、变量、参数等
若修饰类，则此类不能被继承；
若修饰方法，则此方法不能被重写；
若修饰成员变量，则此变量必须初始化或者提供相应的构造器进行初始化；
若修饰变量，则此变量必须初始化，表示一个常量；
若修饰参数，则此参数的值不能被改变；

public class finalDemo {
	public final int id = 10;
	public static void main(String[] args) {
		finalDemo te = new finalDemo();
	    //te.id = 20;则会出现报错		
	}
}

༒^O^

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础入门语法

个人学习笔记，学习网站如下https://ke.qq.com/webcourse/index.html#cid=919020&term_id=101017619&taid=6120358462490092&vid=5285890798642890215
复制链接

扫一扫