基础语法
内存和变量:
程序=输入+处理+输出
变量是给保存在内存中的数据起个名字,方便后续操作
变量的三要素:类型、名称和取值
变量分为:局部变量、实例变量和类变量
//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);
}
}
集合框架