目录
java编程基础
(一)变量的数据类型
- byte:8位
- short:16位
- int:32位
- long:64位
- float:32位
- double:64位
- char:两个字节
(二)类型转换
自动转换,两个条件
- 两种数据类型彼此兼容
- 目标类型的取值范围大于源类型的取值范围
(三)运算符
1.除法:如果都是整数,最后结果也是整数,如果有小数,最后结果位小数
2.异或(^):符号两边不相同时为真,相同为假
4.&和&&(短路与):&两边都会运算,然后按照规则比较;&&如果左边为假,右边不会运算
(四)数组
定义:int[] x=new int[3];
初始化:
int[] x=new int[]{1,2,3};
int[] x={1,2,3};
常见操作(Arrays对象):
1.打印数组:Arrays.toString(x);
2.拷贝数组:Arrays.copyOf(x,x.length);
3.数组排序:Arrays.sort(x);
package Test;
import java.util.Arrays;
public class Test {
public static void main(String[] args){
int[] x={2,1,4,5,3,5,9,7};
int[] x2=Arrays.copyOf(x, x.length);
Arrays.sort(x);
System.out.println(Arrays.toString(x));
System.out.println(Arrays.toString(x2));
}
}
多维数组:
int[][] x=new int[3][]
第二个空可以不写。3行n列
int[][] x={{1,2},{3,4,5,6},{7,8,9}};
package Test;
import java.util.Arrays;
public class Test {
public static void main(String[] args){
int[][] x={{1,2},{3,4,5},{6,7,8,9}};
System.out.println(x.length);
System.out.println(x[2].length);
System.out.println(Arrays.deepToString(x));
}
}
数组列表-ArrayList
不能添加基本类型,如int、double等
ArrayList<String> strList=new ArrayList<String>();
ArrayList<String> strList=new ArrayList<>();
List<String> strList=new ArrayList<>();
StringBuilder类,对字符串的频繁修改时使用
StringBuilder stringbuilder=new StringBuilder();
stringbuilder.append();
capacity(容量),length实际长度
(五)构造函数
package Person;
public class Person {
private String name;
private int age;
public Person(){
this("NULL",0);
}
public Person(String name,int age){
this.name=name;
this.age=age;
}
public static void main(String[] args) {
Person per=new Person("孟祥威",100);
Person per1=new Person();
System.out.println(per.name+", "+per.age);
System.out.println(per1.name+", "+per1.age);
}
}
(六)static
- 属于类,不属于对象
- 可以直接用类名来调用
- 静态不能直接调用非静态
(七)final
- final修饰基本类型变量,变量值不能更改
- final修饰引用类型,引用不能更改,但是指向的值可以改变
- final修饰类,类不能被继承
public final class Father{
}
- final修饰方法,该方法不能被子类覆盖
public final void test(){
}
(八)继承1
-
关键字:extends
-
父类中的private在子类中直接使用
-
不能有多个父类
-
所有类的父类-object
- String toString()返回对象的字符串描述
- boolean equals()比较两个对象是否相等(比较引用)
- int hasCode()
- Object clone() 克隆一个对象
- Class getClass() 返回当前类的Class对象
(九)覆盖(override)
-
父类的某个方法在子类中重新定义,以体现子类的特有行为
-
子类的方法签名(方法名+参数数量和类型)和返回类型都与父类对象中的对应方法相同
-
子类覆盖的时候不要降低父类方法的可见性
-
子类覆盖的方法可以返回被覆盖方法所返回类型的子类型
父类:public Object test();
子类:public String test(); -
子类覆盖的方法签名要与父类相同
-
加上@Override可以防止错误
(十)super
屏蔽属性:子类的属性名和父类属性名相同,则会屏蔽父类
通过super可以调用父类方法与属性
super.父类属性
super.子类属性
super(x,y,z):
调用父类构造器,必须放在第一行
如果没有显示的调用父类构造器,将调用默认构造器
如果父类有有参构造幻术,但没有无参构造函数,且没有显示的调用父类构造器,将会报错
(十一)多态
- 可以使用父类类型变量指向子类类型对象
Shape cir=new Circle();
但是父类类型不能操作子类特有方法 - 根据其所引用的类型来调用方法
- 不能将父类类型变量赋给子类
- instanceof关键字
测试对象实际类型,结果为true or false
实现安全的类型转换
Shape[] shapes=new Shapes[3];
Shape[0]=new Circle();
Shape[1]=new Rect();
Shape[2]=new Circle();
for(Shape e:shapes){
if(e instanceof Circle){
Circle x=(Circle)e;
System.out.println(x.getRadius());
}
}
(十二)抽象类–abstract
- 修饰类
public abstract class Shape{
}
抽象类不能实例化,只能作为其他类的父类
生来就应该被继承
2. 修饰方法
public abstract double getArea(){
}
只有声明没有实现
3. 抽象类中可以有非抽象方法
(十三)接口
- 接口与类相似,是一个引用类型
- 使用interface关键字进行声明
- 非默认方法、非静态方法声明为abstract
- 接口不能实例化
- 由其它类实现(implements)
- 接口数组可以实例化
interface Fly {
public abstract void fly();//没有方法体
}
class Plane imlements Fly{
@Override
public void fly(){
System.out.println("sss");
}
}
public class Bird implements Fly {
@Override
public void fly(){
System.out.println("Bird can fly");
}
}
public class Mian {
public static void main(String[] args) {
Fly a=new Plane();
Fly b=new Bird();
Fly[] e=new Fly[2];
e[0]=a;
e[1]=b;
for(Fly c:e){
c.fly();
}
}
}
- 一个类可以实现多个接口
class Plane implements Fly, Comparable{
}
Comparator例子
package comparable;
public class Emp {
private int age;
private String name;
private int money;
public Emp(){
this(0,"NULL",0);
}
public Emp(int age,String name,int money){
this.age=age;
this.name=name;
this.money=money;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
@Override
public String toString(){
return "姓名:"+name+", "+"年龄:"+age+", "+"薪水:"+money;
}
}
package comparable;
import java.util.Comparator;
public class Comp implements Comparator<Emp> {
@Override
public int compare(Emp arg0, Emp arg1) {
if(arg0==arg1)
return 0;
int cn=arg0.getName().compareTo(arg1.getName());
if(arg0.getName()!=arg1.getName())
return cn;
else if(arg0.getMoney()!=arg1.getMoney())
return arg0.getMoney()-arg1.getMoney();
else if(arg0.getAge()!=arg1.getAge())
return arg0.getAge()-arg1.getAge();
else
return 0;
}
}
package comparable;
import java.util.Arrays;
public class Min{
public static void main(String[] args){
Emp x1=new Emp(10,"meng",100);
Emp x2=new Emp(12,"xiang",50);
Emp x3=new Emp(14,"wei",120);
Emp x4=new Emp(20,"dada",113);
Emp[] x={x1,x2,x3,x4};
Arrays.sort(x,new Comp());
for(Emp e:x)
System.out.println(e);
}
}
Cloneable对象
- 以下不是克隆,仅仅是拷贝引用指针
克隆是在堆内存中重新生成一个对象
Emp a=new Emp();
Emp b=a;//拷贝指针
- 如果要调用Object的clone方法
- 必须实现Cloneable这个标识接口
- 在子类中覆盖clone方法,调用super.clone
- 一般不需要在自定义的类中实现clone
- 所有的数组类型均包含一个clone方法
(十四)嵌套类
- 内部类可以访问外部类的所有属性和方法,包括private属性
- 创建内部类对象,必须先有外部类,然后才能创造其内部类
OutClass outerObject=new OutClass();
OutClass.InClass inerObject=outObject.new InClass();
- 覆盖(使用外部类需要加上类名)
(十五)匿名类
方法体内声明,但不对类进行命名
public class OIN {
public int x=1;
@Override
public String toString(){
return "外部";
}
public static void main(String[] args) {
OIN tt=new OIN();
OIN t=new OIN(){
@Override
public String toString(){
return "内部";
}
};
System.out.println(t);
System.out.println(tt);
}
}