Java基础语法

最新推荐文章于 2022-10-25 00:10:47 发布

DLANDML

最新推荐文章于 2022-10-25 00:10:47 发布

阅读量192

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/l641208111/article/details/104299150

版权

Java 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

基础语法

内存和变量：

程序=输入+处理+输出

变量是给保存在内存中的数据起个名字，方便后续操作

变量的三要素：类型、名称和取值

变量分为：局部变量、实例变量和类变量

//eclipse ide-新建工程-建包-建Demo01.java
package com.csdn;
public class Demo01{//类名首字母大写,且与文件名一致
        static void testVar(){
            #方法
            String name='lv';
            int age=30;
            String color ='黑色'
    }
      static void testId(){
            #方法
            #驼峰法命名规则：类名首字母大写，方法名称和变量名称首字母小写，单词分割大写
            String custormerName='lv';
            int customerAge=30;
            double customerSalary =9000;
    }
    public static void main（String[] args）{
        testVar();
    }

}

#输出：lv,30,黑色

标识符：

标识符就是给类、变量、方法、接口其的名字。

标识符的命名规则：

所有的标识符以字母（A-Z/a-z）/美元符$/下划线（_）开始

首字符之后可以任何字符组合

关键字不能作为标识符

标识符大小写敏感

合并标识符举例：age, $salary, _value, _1_value

非法标识符举例：11123abc, -salary

关键字：用于描述Java语法的特殊单词

访问控制	private	protected	public
类、方法和变量修饰符	abstract	class	extends	final	implements	interface	native	new
类、方法和变量修饰符	static	strictfp	synchronized	volatile
程序控制	break	continue	return	do	while	if	else	for
程序控制	instanceof	switch	case	default
错误处理	try	cathc	throw	throws
包相关	import	package
基本类型	boolean	byte	char	double	float	int	long	short
基本类型	null	super	this	void
变量引用	super	this	void
保留字	goto	const

类和对象:

类：是一个模板，是抽象的，他描述一类对象的行为和状态

对象：是类的一个实例，是具体的

由类创建对象的过程叫做实例化

方法：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。

属性：每个对象都有独特的属性（实例变量），对象的状态由这些属性的值决定。

package com.csdn;

public class Demo2{
        public staic void main(String[] args){
            Boy kite = new Boy();#实例化
            kite.getMsg();#访问方法
            kite.eat();
            kite.sleep();

            Boy tom = new Boy();
            tom.name="tom"
            tom.age=17;

            tom.getMsg();
            tom.eat();
            tom.sleep();
    }

}
class Boy{#类名

           String name="kite";//属性
           int age = 18;
            public void getMsg(){
                System.out.println(name+","+age);
            }
           public void eat(){#方法行为
            System.out.println("吃饭");
    } 
          public void sleep(){
            System.out.println("睡觉");
    } 

}

基础数据类型

数据类型-数据类型有哪些-数据类型实例

数据类型：

当创建变量时，需要申请内存空间

系统根据变量的数据类型，来分配空间大小

数据类型哪些：

Java语言提供了8种数据类型。6中数字类型（4个整数型，2个浮点型），一种字符类型，一种布尔型。

基本类型	大小	范围
boolean	1字节8位	true,false
byte	1字节8位有符号整数	-128-+127
short	2字节16位有符号整数
int	4字节32位有符号整数
long	8字节64位有符号整数
char	2字节16位Unicode字符	0-65535
float	4字节32位浮点数
double	8字节64位浮点数

数据类型实例:通过实例，查看数据类型封装类和取值范围

//基本数据类型 的封装类

System.out.println(Byte.MIN_VALUE+","+Byte.MAX_VALUE+","+Byte.SIZE)
//输出-128,127,8

运算符和表达式

算术运算-关系运算-逻辑运算-赋值运算-条件运算（三元运算）

算术运算：+ - * / %

static void testMath{
     int a=(int) (Math.random()*100);
     int b=(int) (Math.random()*100);
}

关系运算：> >= < <= == !=

逻辑运算:& | ! &&(短路与，如果前面的表达式可以确定结果后面的表达式不再计算) ||(短路或，)

赋值运算:= += -= *= /= %= ++ --

条件运算:max=x>y?x:y;

字符串和数组

字符串广泛应用在java编程中，在java中字符串属于对象，JAVA提供了String类来创建和操作字符串

直接赋值创建字符串：String name='tom'

使用构造函数创建字符串:String name1=new String('kite')

获取字符串长度:name1.length()

字符串连接：使用+号；使用concat方法

字符串格式化：String.format %c %d %s %b %f

static void testStr1(){
        String name='tom'
        int age=20;
        double salary=999.666
        String msg = String.format("姓名：%s,年龄：%d,薪水：%.2f",name,age,salary)
}
输出：姓名：tom, 年龄：20， 薪水：999.666

字符串方法：charAt、length、substring、trim、indexOf

数组：数组大小固定-保存的数据类型相同-数组的声明-数组的初始化

static void testArray(){

    int[] arr1={1,2,3,4}
    //等价于int arr[]={1,2,3,4}在java中一般将[]写在前面。

    int[] arr2= new int[5];//5为数组长度

     
}

数组的使用：遍历数组、数组作为参数、数组作为返回值

遍历数组：

static void testArray(){

    int[] arr1={1,2,3,4}
    //等价于int arr[]={1,2,3,4}在java中一般将[]写在前面。
    for each
    for (int i ： a){
        System.out.println(i);
    }

    int[] arr2= new int[5];//5为数组长度

     
}

数组做参数：


static void testArray1(int[] a){

    //for each
    for (int i ： a){
        System.out.println(i);
    }
     
}

String[] names={'tom','kite','rose'};
testArray1(names);

数组作为返回值:


static String[] testArray4(){

   String[] names={'tom','kite','rose'};
   return names;
     
}

public static void main(String[] args){
    String[] s2=testArray4();
    for (String string :s2){
        System.out.println(string);
    }
}

Arrays工具类：sort排序、binarySearch二分查找


static String[] testArray5(){

   int[] a={9,2,3,3,7,3,6,7,5353,3,89}
    Arrays.sort(a);//排序
    System.out.println(a);
    #查找索引
    int idx=Arrays.binarySearch(a,7);
     
}

流程控制

程序的执行顺序-java循环-java分支

执行顺序：从入口程序main开始执行；程序自伤而下顺序执行；遇到方法调用程序跳转到方法调用处继续执行，方法执行完毕，再跳转到调用方法处。

循环：for /for each（for i:a）; while/do while ;break/continue 关键字

分支：if else 、switch

面向对象

类和对象、java接口、java继承、java多态

类和对象：类和对象-构造方法-类变量和实例变量-类方法和实例方法-this关键字


public class Demo2{
        public staic void main(String[] args){
//有类产生对象的过程叫实例化
//对象objec==实例
//由一个类可以创建多个实例
            Boy kite = new Boy();#实例化
            kite.getMsg();#访问方法
            kite.eat();
            kite.sleep();

            Boy tom = new Boy();
            tom.name="tom"
            tom.age=17;

            tom.getMsg();
            tom.eat();
            tom.sleep();
    }

}
//类变量和类方法，也叫静态变量和静态方法
//特点，不需要实例化，直接通过类名称访问
//this是一个指代对象，当前对象是谁，this就指向谁
class Boy{#类名
            //实例变量
           String name="kite";//属性
           int age = 18;
//构造方法，构造自己的一个方法
//特点1：没有返回值，连void返回值也木有
//特点2：构造方法名与类名必须相同
//
            public Boy(){
                System.out.println(name+","+age);
            }
            public Boy(String name,int age){
                this.name=name;
                this.age=age;
            }
//实例方法
           public void eat(){#方法行为
            System.out.println("吃饭");
    } 
          public void sleep(){
            System.out.println("睡觉");
    } 


}

接口：定义-实现-继承

定义：


//接口内的方法必须是空的
//更好的实现程序的抽象
//产品经理做这个，具体的内容交由下面人去实现；
interface Anial{
    public void eat();
    public void sleep();
    public void play();

}
interface Bird{
    public void fly();

}
interface Fish{
    public void swim();

}
//一个类可以有多个接口
class FlyFish implements Bird,Fish{


}

interface Player{
    public void play();
}
//接口的继承
interface videoPlayer extends Player{
    public void playvideo();
}
//手机调用接口videoPlayer，接口的Player方法也能访问、
//ctrl+1
class Moblie implemnts videoPlayer{

      public void play(){}
      public void playVideo(){}
}
//虽然都是猫和狗吃、睡，但猫和狗的吃、睡方法不一样
class Dog inplements Anial{
  public void eat(){#方法行为
            System.out.println("吃饭");
    } 
          public void sleep(){
            System.out.println("睡觉");
    } 

}
class Cat inplements Anial{//ctrl+1
  public void eat(){#方法行为
            System.out.println("吃饭");
    } 
          public void sleep(){
            System.out.println("睡觉");
    } 

}

public class Demo2{
        public staic void main(String[] args){
            Dog dog = new Dog();#实例化
            dog.eat();
            dog.sleep();

           Cat cat = new Cat();

            cat.eat();
            cat.sleep();
    }

}

继承：继承语法（extends）-方法覆盖-方法重载-super关键字

class Animals{

    private String privaterStr='privaterrStr'
    String name='huahua';
    protected int age=2;
    public String color='黑色';
    
    public void eat(){}
    private void m1(){}
    protected void m2(){}
    void m3(){}
}
//继承上面Animals类
//方法覆盖是在继承关系里面，子类覆盖父类同名方法
//super是父类的应用
//this指代当前对象
class Dog extends Animals{
    @override//覆盖父类方法
    public void eat(){
      super.eat();//super代表父类

    }
}
//方法重载，方法名称相同，参数的个数或类型不同
//方法重载是在一个类里面
class Person{
//构造方法重载
String name;
int age;
public Person(){}
public Person(String name){this.name=name}
public Person(String name, int age){this.name=name;this.age=age;}
    public void eat(){}
    public void eat(sring food){}

}
//继承可以继承除private以外的所有属性与方法
//object是 java中的顶级父类
public class Demo11{
    public static void main(String[] args){
        Dog dog=new Dog();
        System.out.println(dog.age)                                                      
        System.out.println(dog.color)                                                      
        System.out.println(dog.name)                                                      
        System.out.println(dog.privatteStr)#不可访问                                                      
        dog.eat();
        dog.m2();
        dog.m3();
        dog.m1();//不可使用                                                   
                                                                       
    }

}

java多态：java多态 -向上类型转换-方法的动态绑定

比如;一个人要养猫狗，我们不是直接访问猫狗，而是利用向上类型转换的多态性，访问动物，当我们想要加入其它动物再访问时，只需要在动物下面加其它动物即可，我们访问的动物类型不会变，这样可以使程序更具有扩展性。

class Animals{

    private String privaterStr='privaterrStr'
    String name='huahua';
    protected int age=2;
    public String color='黑色';
    
    public void eat(){}
    private void m1(){}
    protected void m2(){}
    void m3(){}
}
//继承上面Animals类
//方法覆盖是在继承关系里面，子类覆盖父类同名方法
//super是父类的应用
//this指代当前对象
class Dog extends Animals{
    @override//覆盖父类方法
    public void eat(){
      super.eat();//super代表父类

    }
}
//方法重载，方法名称相同，参数的个数或类型不同
//方法重载是在一个类里面
class Person{
//构造方法重载
String name;
int age;
public Person(){}
public Person(String name){this.name=name}
public Person(String name, int age){this.name=name;this.age=age;}
    public void eat(){}
    public void eat(sring food){}

}
//继承可以继承除private以外的所有属性与方法
//object是 java中的顶级父类
public class Demo11{
    public static void main(String[] args){
        Dog dog=new Dog();
        System.out.println(dog.age)                                                      
        System.out.println(dog.color)                                                      
        System.out.println(dog.name)                                                      
        System.out.println(dog.privatteStr)#不可访问                                                      
        dog.eat();
        dog.m2();
        dog.m3();
        dog.m1();//不可使用                                                   
                                                                       
    }

}




interface Animal{

public void eat();
public void sleep();

}

class Dog implements Animal{
    @override//覆盖
    public void eat(){}
    @override//覆盖
    public void sleep(){}
}
class Cat implements Animal{
    @override//覆盖
    public void eat(){}
    @override//覆盖
    public void sleep(){}
}
class Snake implements Animal{
    @override//覆盖
    public void eat(){}
    @override//覆盖
    public void sleep(){}
}
//一个人既要养猫。又要将狗，具有扩展性
class Person{
    public void care(Cat cat){
            cat.eat();
            cat.sleep();
    }
     public void care(Dog dog){
            dog.eat();
            dog.sleep();
    }
    
//既然养猫养狗都继承于Aniama,则下列方法更具有扩展性
  public void care(Animal a){
            a.eat();
            a.sleep();
    }

}
//java多态，一个方法有多种状态
public class Demo12{
    public static void main(String[] args){
        Animal dog=new Dog();  //向上继承 ，动态绑定                                                 
        dog.eat();
        dog.sleep();

        Animal cat=new Dog();                                                    
        cat.eat();
        cat.sleep();  

        Animal snake=new Snake();                                                    
       
        Person p=new Person();                                                    
        p.care(cat);
        p.care(dog);   
        p.care(snake);                                    
                                                                       
    }

}

集合框架

DLANDML

关注

0
点赞
踩
0

收藏

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

基础语法内存和变量：程序=输入+处理+输出变量是给保存在内存中的数据起个名字，方便后续操作变量的三要素：类型、名称和取值变量分为：局部变量、实例变量和类变量//eclipse ide-新建工程-建包-建Demo01.javapackage com.csdn;public class Demo01{//类名首字母大写,且与文件名一致 static voi...
复制链接

扫一扫