1、基础语法
1.1、数据类型
1.1.1、Java数据类型
- 基本数据类型
- 数值型
- 整数类型
- byte —> Byte
- short —> Short
- int ----> Integer
- long —> Long
- 浮点类型(float,double)
- float —> Float
- double —> Double
- 整数类型
- 字符型(char)
- char —> Character
- 布尔型(boolean)
- boolean —> Boolean
- 数值型
- 引用数据类型
- 类(class)
- 接口(interface)
- 数组([])
注意:
- 1、原始类型无法直接使用包装类里面的方法
- 2、原始数据不能为null,而包装类可以为null
数值型类型互转:
Byte zj = 0x0A;
System.out.println("方法1_Byte转Int结果 --> "+(int)zj);
System.out.println("方法2_Byte转Int结果 --> "+Integer.valueOf(zj));
System.out.println("方法3_Byte转Int结果 --> "+(zj&0xff));
System.out.println("方法4_Byte转Int结果 --> "+(zj));
Integer i = 20; //Double Float Integer String 都可以使用valueOf来互相转换类型,前提是数值
System.out.println("i转换为Double ---> " + Double.valueOf(i));
System.out.println("i转换为Float ---> " + Float.valueOf(i));
System.out.println("i转换为String ---> " + String.valueOf(i));
System.out.println("i转换为String ---> " + i.toString());
System.out.println("i转换为String ---> " + i + "");
Boolean flag = false;
System.out.println("flag转String ---> "+ flag.toString());
Integer a = new Integer(3);
Integer b = 3; // 将3自动装箱成Integer类型
int c = 3;
System.out.println(a == b); // false 两个引用没有引用同一对象
System.out.println(a == c); // true a自动拆箱成int类型再和c比较
System.out.println(b == c); // true
Integer a1 = 128;
Integer b1 = 128;
System.out.println(a1 == b1); // false
Integer a2 = 127;
Integer b2 = 127;
System.out.println(a2 == b2); // true
1.1.2、Math.round 四舍五入
System.out.println(Math.round(11.1));//返回值11
System.out.println(Math.round(11.2));//返回值11
System.out.println(Math.round(11.3));//返回值11
System.out.println(Math.round(11.4));//返回值11
System.out.println(Math.round(11.5));//返回值12
System.out.println(Math.round(11.6));//返回值12
1.1.3、编码
Java语言采用Unicode编码标准,Unicode(标准码),它为每个字符制订了一个唯一的数值
1.1.4、访问修饰符
定义:Java中,可以使用访问修饰符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。
分类
private : 在同一类内可见。使用对象:变量、方法。 注意:不能修饰类(外部类)
default (即缺省,什么也不写,不使用任何关键字): 在同一包内可见,不使用任何修饰符。使用对象:类、接口、变量、方法。
protected : 对同一包内的类和所有子类可见。使用对象:变量、方法。 注意:不能修饰类(外部类)。
public : 对所有类可见。使用对象:类、接口、变量、方法
1.1.5、关键词
1、final
- final可以修饰类、变量、方法,修饰类表示该类不能被继承、修饰方法表示该方法不能被重写、修饰变量表示该变量是一个常量不能被重新赋值。
2、 this关键字的用法
this是自身的一个对象,代表对象本身,可以理解为:指向对象本身的一个指针。
this的用法在java中大体可以分为3种:
①. 普通的直接引用,this相当于是指向当前对象本身。
②. 形参与成员名字重名,用this来区分:
3、 static应用场景
因为static是被类的实例对象所共享,因此如果某个成员变量是被所有对象所共享的,那么这个成员变量就应该定义为静态变量。
因此比较常见的static应用场景有:
- 修饰成员变量
- 修饰成员方法
- 静态代码块
- 修饰类【只能修饰内部类也就是静态内部类】
- 静态导包
static注意事项
- 静态只能访问静态。
- 非静态既可以访问非静态的,也可以访问静态的。
2、面向对象
Object类是一切java类的父类,对于普通的java类,即便不声明,也是默认继承了Object类。
所有的类均默认继承了Object,下图是Object继承的父方法
面向对象的三大核心特性:
- 可重用性:代码重复使用,减少代码量,提高开发效率。面向对象的三大基本特征(继承、封装和多态)都围绕这个核心。
- 可扩展性:指新的功能可以很容易地加入到系统中来,便于软件的修改。
- 客观理性:能够将功能与数据结合,方便管理。
2.2、类
类:用来描述一类具有相同特征(属性)和相同行为(方法)的对象。(可以比喻为模板)
-
Java中用class关键字来描述类
- 成员属性(变量):对应的就是事物的属性
- 成员方法:对象事物的行为
2.2、继承
继承的特点:
-
继承要有一定的层次结构,而且还要具备一定的可传递性
-
子类继承了父类的所有属性和方法,但是不包括私有属性(private)和构造方法
-
子类继承父类的属性和方法同时也可以有自己的属性和方法。
-
Java 只支持单继承。 也就是说一个子类只能有一个父类,父类可以有多个子类
-
-
继承可以减少重复代码、提高了复用性和维护性
-
继承让类与类之间产生了关系,类的耦合性增强了,父类发生变化子类也会跟着改变
继承的好处和弊端
好处:
-
提高了代码的复用性(多个类相同的成员可以放到一个类当中)
-
提高了代码的维护性(如果方法的代码需要修改,只需修改一处即可)
弊端:
-
继承让类与类之间产生了关系,类的耦合性也增加了,当父类发送变化时候,子类也不得不跟着变化,削弱了子类的独立性。
所以继承的使用需要考虑周全,那么什么时候使用继承比较好呢? -
继承关系的体现:is a
-
假设法:我有两个类A和B,如果满足A是B的一种,或者B是A的一种,就说明他们存在继承关系,这个时候就可以考虑使用继承,否则不能滥用继承
2.3、重写
重写的的前提是继承父类
概述:
- 子类中出现了和父类一模一样的声明
- 当子类需要父类的功能,而功能主体中,子类有自己独特的内容,就可以通过重写父类中的方法,这样,即沿袭了父类的功能,又定义了自己的特有内容
方法重写的注意事项:
- 父类中的私有内容是无法重写的(private修饰)
- 子类重写父类方法的时候,方法访问权限不能低于父类方法的访问权限
(访问权限:public>默认(即不写修饰符)>private)
2.4、重载
重载(overload):在同一个类中,允许存在一个以上的同名函数,只要他们的参数个数或者参数类型不同即可。比如,如果没有重载,我们在写求和这个方法时,必须写一个对整数的,再写一个对小数的。这样非常麻烦且不易调用。但有了重载以后,我们可以把对整数和小数的求和整合到一个方法中,不论往里面传的是小数还是整数都可以通过一次调用解决。
特点:与返回值类型无关,只看参数列表(参数的个数、参数的类型、参数的顺序)。
//父类
public class Animal {
private String name;//名称
private int month;//月份
private String species;//种类
//构造器重载
public Animal(){}
public Animal(String name){
this.name = name;
}
public Animal(String name,String species){
this.name = name;
this.species = species;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month = month;
}
public String getSpecies() {
return species;
}
public void setSpecies(String species) {
this.species = species;
}
}
//子类
public class Dog extends Animal{
public String run(){
return (this.getName()+"在跑步是一条"+this.getSpecies());
}
public void setName(String name,String ss) {
this.setName(name);
this.setSpecies(ss);
System.out.println("狗类使用了重载");
}
}
//子类
public class Mao extends Animal{
public String sleep(){
return (this.getName()+"在睡觉是一条"+this.getSpecies());
}
@Override
public String getName() {
System.out.println("我重写了Animal的方法");
return super.getName();
}
}
public static void main(String[] args) {
Dog dog = new Dog();
dog.setName("小狗狗","狗");
System.out.println(dog.run());
Mao mao = new Mao();
mao.setName("小猫猫");
mao.setSpecies("猫");
System.out.println(mao.sleep());
Animal dog_2 = new Dog();
Dog dog_3 = (Dog) dog_2;
System.out.println("使用了多态,并向下强制转型使用子类特有的方法");
dog_3.setName("小狗","红狗");
System.out.println(dog_3.run());
//dog_2.setName("小狗","狗1"); 无法调用,语法错误,多态不使用强制向下转型就无法使用子类特有的方法
//System.out.println(dog_2.run());
}
//狗类使用了重载
//小狗狗在跑步是一条狗
//我重写了Animal的方法
//小猫猫在睡觉是一条猫
//使用了多态,并向下强制转型使用子类特有的方法
//狗类使用了重载
//小狗在跑步是一条红狗
2.5、多态
多态是继封装、继承之后,面向对象的第三大特性。
多态现实意义理解:
-
现实事物经常会体现出多种形态,如学生,学生是人的一种,则一个具体的同学张三既是学生也是人,即出现两种形态。
-
Java作为面向对象的语言,同样可以描述一个事物的多种形态。如Student类继承了Person类,一个Student的对象便既是Student,又是Person。
多态体现为父类引用变量可以指向子类对象。
前提条件:必须有子父类关系。
注意:
- 在使用多态后的父类引用变量调用方法时,会调用子类重写后的方法。
- 在使用多态的时候,无法使用子类独有的子类方法和变量,需要进行向下转型
多态的定义与使用格式
- 定义格式:父类类型 变量名=new 子类类型();
以下的继承的图,没重写和重载没多态