java学习内容-2

目录

• ​​java编程基础​​

• ​​（一）变量的数据类型​​
• ​​（二）类型转换​​
• ​​（三）运算符​​
• ​​（四）数组​​
• ​​（五）构造函数​​
• ​​（六）static​​
• ​​（七）final​​
• ​​（八）继承1​​
• ​​（九）覆盖（override）​​
• ​​(十）super​​
• ​​（十一）多态​​
• ​​（十二）抽象类--abstract​​
• ​​（十三）接口​​

• ​​Comparator例子​​
• ​​Cloneable对象​​

• ​​（十四）嵌套类​​
• ​​（十五）匿名类​​

java编程基础

（一）变量的数据类型

• byte：8位
• short：16位
• int：32位
• long：64位
• float：32位
• double：64位
• char：两个字节

（二）类型转换

自动转换，两个条件

• 两种数据类型彼此兼容
• 目标类型的取值范围大于源类型的取值范围

byte

short

int

long

float

double

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

1. 属于类，不属于对象
2. 可以直接用类名来调用
3. 静态不能直接调用非静态

（七）final

1. final修饰基本类型变量，变量值不能更改
2. final修饰引用类型，引用不能更改，但是指向的值可以改变
3. final修饰类，类不能被继承

public final class Father{
}

4. final修饰方法，该方法不能被子类覆盖

public final void test(){
}

（八）继承1

• 关键字：extends
• 父类中的private在子类中直接使用
• 不能有多个父类
• 所有类的父类-object

1. String toString（）返回对象的字符串描述
2. boolean equals（）比较两个对象是否相等(比较引用）
3. int hasCode()
4. Object clone() 克隆一个对象
5. Class getClass() 返回当前类的Class对象

（九）覆盖（override）

1. 父类的某个方法在子类中重新定义，以体现子类的特有行为
2. 子类的方法签名（方法名+参数数量和类型）和返回类型都与父类对象中的对应方法相同
3. 子类覆盖的时候不要降低父类方法的可见性
4. 子类覆盖的方法可以返回被覆盖方法所返回类型的子类型
   父类：public Object test();
   子类：public String test();
5. 子类覆盖的方法签名要与父类相同
6. 加上@Override可以防止错误

(十）super

屏蔽属性：子类的属性名和父类属性名相同，则会屏蔽父类
通过super可以调用父类方法与属性
super.父类属性
super.子类属性

super（x,y,z)：
调用父类构造器，必须放在第一行
如果没有显示的调用父类构造器，将调用默认构造器
如果父类有有参构造幻术，但没有无参构造函数，且没有显示的调用父类构造器，将会报错

（十一）多态

1. 可以使用父类类型变量指向子类类型对象
   Shape cir=new Circle（）；
   但是父类类型不能操作子类特有方法
2. 根据其所引用的类型来调用方法
3. 不能将父类类型变量赋给子类
4. 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

1. 修饰类

public abstract class Shape{
}

抽象类不能实例化，只能作为其他类的父类
生来就应该被继承
2. 修饰方法

public abstract double getArea(){
}

只有声明没有实现
3. 抽象类中可以有非抽象方法

（十三）接口

1. 接口与类相似，是一个引用类型
2. 使用interface关键字进行声明
3. 非默认方法、非静态方法声明为abstract
4. 接口不能实例化
5. 由其它类实现（implements)
6. 接口数组可以实例化

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();
    }
  }
}

7. 一个类可以实现多个接口

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对象

1. 以下不是克隆，仅仅是拷贝引用指针
   克隆是在堆内存中重新生成一个对象

Emp a=new Emp();
Emp b=a；//拷贝指针

2. 如果要调用Object的clone方法

• 必须实现Cloneable这个标识接口
• 在子类中覆盖clone方法，调用super.clone

3. 一般不需要在自定义的类中实现clone
4. 所有的数组类型均包含一个clone方法

（十四）嵌套类

1. 内部类可以访问外部类的所有属性和方法，包括private属性
2. 创建内部类对象，必须先有外部类，然后才能创造其内部类

OutClass outerObject=new OutClass（）；
 OutClass.InClass inerObject=outObject.new InClass();

3. 覆盖（使用外部类需要加上类名）

（十五）匿名类

方法体内声明，但不对类进行命名

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);
}
}