JAVA记录
-
Java中一个实数默认为double类型，在末尾加f（F）可变为float
获取闭区间[a,b]中的随机数：
(int) (Math.random() * (b - a + 1)) + a //不是闭区间的转换成闭区间
-
int a = 123444532322324424242l,赋给a的数字太大可以在其后加l
-
包名：多单词组成时所有字母均小写zzzxxxccc
类名，接口名：多单词组成时XxxYyyZzz
变量名，方法名：多单词组成时xxxYyyZzz
常量名：所有字母均大写，多个单词时XXX_YYY_ZZZ
-
方法的重载：同名的函数通过不同的形参做类似的事情
要求：1. 函数的形参个数
2.函数的形参顺序
3.函数的形参数据类型
注意：若两函数同名同参但返回值类型不同，构不成函数的重载
//可变个数形参的方法 public void f(String ... vals) { } -
构造器:
class A
{
public int i;
public A (int j)
{
i = j;
} // 构造函数，就是在创建对象时就对类的属性赋初值`
public void show(){
System.out.printf ("%d\n",i);
}
}
class Startup
{
public static void main (String[] args)
{
A aa = new A(3);
aa.show();
}
}
class Customer
{
public Customer()
{
System.out.printf("100");
}
public Customer(int age)
{
this(); //通过this（参数列表）的形式来修饰构造器
//必须写在当前构造器的首行
this.age=age;
}
public Customer(String name, int age)
{
this(age);
this.name=name;
}
}
默认构造器的权限与类的权限保持一致
6.关键字static
若在类的属性前面加上关键字static，则用该类创建出的若干个对象共用同一个属性，同时在创建的对象中可以用类名.属性名的方式访问类中的东西，但必须保证所访问的东西是非私有(private)的
静态方法不能访问非静态成员；非静态方法可以访问静态成员。
| 修饰符 | 类内部 | 同一个包 | 不同包的子类 | 同一个工程 |
|---|---|---|---|---|
| private | Yes | |||
| (缺省) | Yes | Yes | ||
| protected | Yes | Yes | Yes | |
| public | Yes | Yes | Yes | Yes |
对于class的权限修饰只可以用public和default（缺省）
- public类可以在任意地方被访问
- default类只可以被同一个包内部的类访问
7.继承
一个新类从已有的类那里获得其已有的属性和方法，叫做类的继承，新类叫做子类也叫派生类，已有的类叫做父类也叫基类.
实现代码：
class B extends A
{
}
注意：私有的不能被继承，父类中的构造方法也不能被子类继承,所以要想在子类中对继承父类的属性进行初始化，要用到super，方法是super ( i , j ),深层意思是以这种形式调用了父类中的构造方法
8.方法重写
指在子类中重新定义父类中已有的方法.
子类中不允许出现与父类中同名同参不同返回值的方法.
class A
{
protected void f()
{
System.out.printf("Hello");
}
}
class B extends A
{
public void f()
{
System.out.printf("World");
}
//此为方法的重写，需注意重写方法的访问权限不小于原方法的访问权限
}
虽说是方法的重写，但是B类中存在两个f函数，A中继承过来的f函数隐藏存在
不能重写父类中私有化的方法
若被重写方法的返回值类型是A类型，则重写方法的返回值类型可以是A类或者A的子类。比如（Object 》String）
-
多态
使用前提：1. 要有类的继承关系 . 2. 子类一般要重写父类中的方法，否则没有必要用多态 .
3.多态只适用于方法，不适用于属性
class A
{
public void f ()
{
System.out.printf("AAAA");
}
}
class B extends A
{
public void f()
{
System.out.printf("BBBB");
}
public void g()
{
System.out.printf("GGGG");
}
}
class Startup
{
public static void main (String[] args)
{
/*
A aa = new B();
aa.f();
*/
A aa = new A();
B bb = new B();
aa.f(); //结果是AAAA
bb.f(); //结果是BBBB
//aa是父类，比作动物，bb是子类，比作狗
aa = bb; //相当于把狗当动物看，可以
//bb = aa; 相当于把动物当狗看，不可以
aa.f(); //结果是BBBB
/*子类可以发送给父类，（aa=bb）
父类不可以发送给子类，（bb=aa）*/
}
}
这就是多态，同一句代码实现不同的功能。
注意aa.g()是错的，父类的引用指向子类后，不能调用子类中特有的成员，只可以访问重写的方法或者从父类继承过来的成员
- 抽象类（植物类，动物类······）
abstract class A
{
public abstract void f();
}
没有方法体的方法叫做抽象方法
包含抽象方法的类必须声明为抽象类
抽象类不一定有抽象方法
不能new出抽象类对象，但可以定义一个抽象类的引用
abstract 不能用来修饰私有的方法、static的方法、final的方法、final的类
-
final 关键字
可修饰整个类和类中的成员
// 修饰整个类时表示该类是最后一个类，不可被继承 class final A //或者是 final class A { }// 修饰成员变量时表示该变量是一个常变量且必须赋给它一个初值，并且不能改变 class B { final public int x = 3; //或者通过构造方法来给它赋初值 /* final public int y; public B { y = 3; } */ }// 修饰成员方法时表示该方法不能被重写 class C { final public void f() { } }-
接口
JAVA中接口和类是同级关系，jdk7以前接口中可以定义：全局常量和抽象方法
jdk8以后，也可以定义静态方法和默认方法
interface it1 { int x = 1; //必须赋初值 void f(); } /*接口中的属性是public static final 类型,抽象方法是public abstract 类型 可以写成上述格式是因为可以被省略，因为其只能是public static final 和 public abstract类型*/interface it2 { int y = 1; void g(); } abstract class A implements it2 { public void h() { } } //可以通过implements来获得it2中的成员interface it1 { } interface it2 { } interface it3 extends it1,it2 { } //接口可以继承接口，可以继承多个interface it1 { } interface it2 { } class A { } class B extends A implements it1,it2 { } //子类在继承父类的同时也可以通过implements来实现一个或多个接口interface it1 { void f(); } class A implements it1 { public voif f() { System.out.printf ("123"); } public void g() { } } class StartUp { public static void main (String[] args) { it1 it; it = new A(); it.f(); it.g(); //error，只能调用从接口包含过来的方法 /*接口不可以new接口对象，可以定义一个接口引用类型的变量，将其指向实现接口的对象， 达到多态的目的*/ } }13.数组
//第一种方式，赋值了 int number[]; number = new int[]{ 1,2,3,4,5}; //第二种方式,没有赋值 int sum1[] = new int[4]; //第三种方式 int arrays[] = new int[]{ 2,3,1,4,5,2,1}
14.包
package com.Tencent //放在代码的第一行 /*导包操作：1. import com.Tencent.* 导入该包的全部东西 2. import com.Tencent.A 只导入某一个类，该类应为public,成员也应为 Public15.Javabean
所谓Javabean是指符合如下标准的Java类
- 类是公有的
- 有一个无参的构造器
- 有属性，且有对应的get，set方法
16.instanceof
a instanceof A //判断对象a是否是类A的实例 //是 返回true-
equals
equals是一个定义在Object类中的方法，作用是比较两个对象的地址是否相同，但是一些类中重写了这个方法，作用变为比较两个对象的内容是否相同。
public boolean equals (Object obj){ return (this == obj); }//重写equals方法思路： public boolean equals (Object obj){ if (this == obj){ return true; } if (obj instanceof User){ User us = (User)obj; return this.age == u.age && this.name.equals(us.name); } return false; } -
包装类
基本数据类型 包装类 int Integer double Double float Float byte Byte char Character short Short long Long boolean Boolean
-
-
基本数据类型转化为包装类
Integer int1 = new Integer(1); //实际就是调用包装类得构造器 -
包装类转化为基本数据类型
Double double1 = new Double(1.1); double number1 = double1.doubleValue(); -
自动装箱、自动拆箱
//自动装箱 Integer i1 = 10; //自动拆箱 int num = i1; -
基本数据类型、包装类转换为String类型
//基本数据类型-->String //方式一： int a = 12; String str1 = String.valueOf(a); //方式二： String str2 = 12 + ""; //包装类转化为String Float b = 11.1; String str2 = String.valueOf(b); -
String转化为基本数据类型
//String-->基本数据类型 String s1 = "123"; int num = Integer.parseInt(s1);- 单例设计模式
//饿汉式 class A{ private A(){ } private static A aa = new A(); public static A getA(){ return aa; } }//懒汉式 //目前还存在多线程安全问题，以后可修复 Tips:加一个synchronized 就可以修复线程安全问题 class B{ private B(){ } private static B bb = null; public static B getB(){ if(bb == null){
最低0.47元/天 解锁文章
470
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
