Java基础笔记
一、流程控制
（一）Scanner输入
1、next()
-
读取到空白就会自动将其去掉，next()不能得到带有空格的字符串
-
hasNext()可以判断是否还有输入的数据
package com.TEST.Test01;
import java.util.Scanner;
public class Test01 {
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数据：");
if(scanner.hasNext()){//判断是否还有输入的数据
String str = scanner.next();//从键盘接收输入数据
System.out.println("输出为："+str);
}
scanner.close();//关闭IO流
}
}
2、nextLine()
-
以Enter为结束符，可以获得空白
-
hasNextLine()可以判断是否还有输入的数据
package com.TEST.Test01;
import java.util.Scanner;
public class Test01 {
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数据：");
if(scanner.hasNextLine()){//判断是否还有输入的数据
String str = scanner.nextLine();//从键盘接收输入数据
System.out.println("输出为："+str);
}
scanner.close();//关闭IO流
}
}
3、一般使用形式
package com.TEST.Test01;
import java.util.Scanner;
public class Test01 {
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
System.out.println("请输入：");
String str = scanner.nextLine();
System.out.println("输出："+str);
scanner.close();//关闭IO流
}
}
4、其它使用
scanner.nextInt();//输入整数
scanner.nextFloat();//输入小数
scanner.nextDouble();
……
(二)break和continue
1、break
break用于强行退出循环，不执行循环中剩余的语句。
2、continue
continue用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的语句。
（三）print和println
1、print
print输出完不会换行
System.out.print("x");//输出只有一个x，没有换行符
System.out.print("x\n");//这个输出和System.out.println("x")是一样的
2、println
println输出完会换行
System.out.println();//相当于一个换行符\n
System.out.println("x");//相当于x\n
3、输出三角形
package com.TEST.Test01;
public class SanJiaoXing {
public static void main(String[] args){
for(int i = 1;i<=5;i++){
//打印左边一半的三角形
for(int j = 5;j>i;j--){
System.out.print(" ");
}
for(int j = 1;j<=i;j++){
System.out.print("*");
}
//打印右边一半的三角形
for(int j =1;j<i;j++){
System.out.print("*");
}
System.out.println();//换行
}
}
}
二、方法
（一）public中void,int……的意义
package com.TEST.Test01;
public class Test02 {
public static void main(String[]args){//这里的void表示不返回
int sum =add(1,2);
System.out.print(sum);
}
public static int add(int a,int b){//这里的int表示的是该方法返回的是int类型字符
return a+b;
}
}
(二)方法的重载
- 方法名称必须相同
- 参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）
- 方法的返回类型可以相同也可以不相同
- 仅仅返回类型不同不足以成为方法的重载
(有很多个名称相同的方法，根据参数的不同自动选择对应的方法)
三、数组
（一）数组的声明和创建
//声明和创建数组
//类型[] 名称 = new 类型[Size]
int[] nums = new int[10];
//数组的长度
//名称.length
nums.length;
（二）三种初始化
- 静态初始化
int[] a = {1,2,3};
- 动态初始化
int[] a = new int[2];
a[0] = 1;
a[1] = 2;
- 数组的默认初始化
数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
（三）稀疏数组
………
四、面向对象
（一）构造器
package com.TEST.Test01;
public class Test04 {
//一个类即使什么也不写，它也会默认存在一个方法，也就是内容为空的（第一个）public Test04()
//这个类就是显示的定义构造器
String name;
//可以使用Alt+insert来补全这个构造器，OK为有参，select None为无参
//无参构造（可以不写，默认会有）
public Test04(){
}
//有参构造：一旦定义了有参构造，无参就必须显示定义（可能界面上没有显示这个定义，但实质上是已经定义了的）
public Test04(String name){
this.name = name;
}
}
package com.TEST.Test01;
public class Test03 {
public static void main(String[] args){
//使用new关键字，本质是在调用构造器，可以用来初始化值
/*
Test04 dog = new Test04();//调用无参的Test04方法，输出为 null
//假如有这句话，输出为 小明
dog.name = "小明";
*/
Test04 dog = new Test04("小明");//调用有参的Test04方法，输出为 小明
System.out.println(dog.name);
}
}
-
使用new关键字创建对象
-
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。
（每个类即使什么方法也不调用，它都会默认执行无参构造）
构造器的特点：
- 必须和类的名字相同
- 必须没有返回类型，也不能写void
如果重写了有参构造，必须要把无参构造加进去
（二）封装
高内聚，低耦合：类的内部数据操作细节自己完成，不允许外部干涉；仅暴露少量的方法给外部使用。
属性私有，get/set
- 提高程序的安全性，保护数据
- 隐藏代码的实现细节
- 统一接口
- 系统可维护增加了
package com.TEST.Test01;
public class Test05 {
private String name;
private int id;
private char sex;
private int age;
//其它类无法直接操作private封装的这些数据，但可以通过get\set方法来改变这些数据
//可以使用Alt+insert
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public int getId() { return id; }
public void setId(int id) { this.id = id; }
public char getSex() { return sex; }
public void setSex(char sex) { this.sex = sex; }
public int getAge() { return age; }
//可以用来确定范围，保护数据
public void setAge(int age) {
if(age <= 0 || age > 150){
System.out.println("输入错误！");
}else {
this.age = age;
}
}
}
package com.TEST.Test01;
public class Test06 {
public static void main(String[] args){
Test05 s1 = new Test05();
s1.setName("小明");
System.out.println(s1.getName());
s1.setAge(-1);
System.out.println(s1.getAge());
}
}
（三）继承
1、extends
-
子类继承父类，就会拥有父类的全部方法（public和默认方法），私有的东西（private）无法被继承
-
在Java中，所有的类都默认直接或者间接继承Object类
-
使用Ctrl+H可以查看类的关系
2、super
注意：
- super调用父类的构造方法，必须在构造方法的第一个！（如果不写调用构造方法，系统会默认先调用父类无参构造再调用子类的无参构造）
- super必须只能出现在子类的方法或者构造方法中
- super和this不能同时调用构造方法
this和super的区别
- 代表的对象不同：this代表本身调用者这个对象，super代表父类对象的应用
- 前提：this没有继承也可以使用，super只能在继承条件中才可以使用
- 构造方法：this()本类的构造，super()父类的构造
package com.TEST.extend;
public class Appaplication {
public static void main(String[] args){
/*程序运行时会先调用无参构造方法，当有继承时，先调用父类的无参构造，再调用子类的无参构造*/
Students s = new Students();
s.print("小红");
}
}
package com.TEST.extend;
public class Person {
public String name = "XM";
public Person(){
System.out.println("调用了父类Person的无参构造");
}
}
package com.TEST.extend;
public class Students extends Person{
String name = "小明";
public Students(){
System.out.println("调用了子类Students的无参构造");
}
public void print(String name){
System.out.println(name);//小红 方法中的
System.out.println(this.name);//小明 最上面这个
System.out.println(super.name);//XM 父类
}
}
3、方法重写
重写都是方法的重写，和属性无关(static和private不能被重写)
需要有继承关系，而且是子类重写父类的方法，只要方法不是private都可以重写
- 方法名必须相同
- 参数列表必须相同
- 修饰符：
- 抛出的异常：范围可以被缩小，但不能扩大：ClassNotFoundException
(子类的方法和父类的方法必须要一致，方法体不同)
Alt+Insert:@override是重写
静态方法与非静态方法的区别：
（静态方法是类的方法，而非静态方法是对象的方法）
-
静态方法(有static)：b调用了B类的方法。因为b是用B类定义的，方法的调用只与左边定义类有关。（static不能重写）
-
非静态方法(没有static，但是重写了):b调用了A类的方法。因为test()方法在子类A中重写了，调用b.test()时就会先执行子类A的test()方法。
package com.TEST.ChongXie;
public class Appaplication {
public static void main(String[] args){
//静态方法：方法的调用只与左边定义类有关
A a = new A();
a.test();//A->test
B b = new A();
b.test();//B->test
}
}
/*父类*/
public class B {
public static void test(){
System.out.println("B->test");
}
}
/*子类*/
public class A extends B{
public static void test(){
System.out.println("A->test");
}
}
下面这个才是重写
package com.TEST.ChongXie;
public class Appaplication {
public static void main(String[] args){
//非静态方法：方法的调用与右边new的对象有关
//重写，先调用子类的方法
A a = new A();
a.test();//A->test
B b = new A();
b.test();//A->test
}
}
/*父类*/
public class B {
public void test(){
System.out.println("B->test");
}
}
/*子类*/
public class A extends B{
public void test(){
@Override//写与不与的结果都是一样的，不过最好把它写上，这样才知道这个方法是重写
System.out.println("A->test");
}
}
（四）多态
对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
父类引用指向子类对象时，子类可以调用自己的方法和父类的方法（B a = new A;//a可以调用子类A和父类B的方法）
如果某个方法是子类独有的（父类没有），那么就会报错，需要类型转换
如果方法没有重写，就执行父类的；如果子类重写了父类的方法，则执行子类的方法
package com.TEST.ChongXie;
public class Appaplication {
public static void main(String[] args){
//非静态方法：方法的调用与右边new的对象有关
A a = new A();
a.test();//A->test
B b = new A();
b.test();//A->test 子类重写了父类的方法，执行子类
a.run();//run 子类独有的方法
/* b.run();//报错 不可以执行子类独有的方法 */
((A) b).run();//类型转换 高转低
}
}
/*父类*/
public class B {
public void test(){
System.out.println("B->test");
}
}
/*子类*/
public class A extends B{
@Override
public void test(){
System.out.println("A->test");
}
public void run(){
System.out.println("run");
}
}
多态注意事项：
- 多态是方法的多态，属性没有多态
- 父类和子类有联系 类型转换异常：ClassCastException
- 存在条件：继承关系，方法需要重写，父类引用指向子类对象！ Father f1 = new Son();
(static、final、private不能重写，也就没有多态)
（五）instanceof
用来判断某个对象是否为某个类或其任意基类的实例（是否在它血源关系的那条线上）
package com.TEST.instance;
public class Application {
public static void main(String[] args){
/*
* Object->Person->Students
* Object->Person->Teacher
* Object->String
*/
//System.out.println(a instanceof Y);//是否能编译通过，存在继承关系则true,不存在则false
Person s1 = new Students();
System.out.println(s1 instanceof Object);//true
System.out.println(s1 instanceof Person);//true
System.out.println(s1 instanceof Students);//true
System.out.println(s1 instanceof Teacher);//false
// System.out.println(s1 instanceof String);//编译错误
Object s2 = new Students();
System.out.println(s2 instanceof Object);//true
System.out.println(s2 instanceof Person);//true
System.out.println(s2 instanceof Students);//true
System.out.println(s2 instanceof Teacher);//false
// System.out.println(s2 instanceof String);//编译错误
Students s3 = new Students();
System.out.println(s3 instanceof Object);//true
System.out.println(s3 instanceof Person);//true
System.out.println(s3 instanceof Students);//true
//System.out.println(s3 instanceof Teacher);//编译错误
// System.out.println(s3 instanceof String);//编译错误
}
}
public class Person {}
public class Students extends Person {}
public class Teacher extends Person {}
（六）类型转换
子类转换为父类，向上转型（会丢失一些方法）；父类转换为子类，向下转型。
//类型转换
Person a = new Student();/*父类引用指向子类*/
((Student) a).run();
public class Application {
public static void main(String[] args){
//类型之间的转换
Person a = new Student();//Person是父类，Student是子类
/*由于父类无法调用子类中的方法，所以要将a由高转换为低，从而能够让a调用子类的方法（独有的方法）*/
((Student) a).run();//类型转换 高转低
}
}
public class Person{}
public class Student extends Person{
public void run(){
System.out.println("run");
}
}
（七）static
1、代码块
{}//匿名代码块
static{}//静态代码块
public class Test08 {
{//2、第二个输出，且只执行一次
System.out.println("匿名代码块");
}
static{//1、第一个输出，可以执行无限次
System.out.println("静态代码块");
}
public Test08(){//3、第三个输出
System.out.println("构造方法");
}
}
public class Test09 {
public static void main(String[] args){
Test08 s1 = new Test08();
System.out.println("===========");
Test08 s2 = new Test08();
}
}
2、静态导入包
import static java.lang.Math.random;//静态导入包（可以导入方法，也可以导入实例）
import static ajva.lang.Math.PI;
public class Test{
public static void main(String[] args){
System.out.println(random());//如果不导入包，就写Math.random()（random（）生成随机数）
System.out.println(PI);
}
}
（八）抽象类 abstract
-
不能new这个抽象类，只能靠子类去实现它，并且子类中要重写抽象类的方法才能使用
-
抽象类中可以写普通的方法
-
抽象方法必须在抽象类中
-
abstract要通过extends实现
package com.TEST.Test01;
public abstract class Test10 {//抽象类
public abstract void A();//抽象方法，只有方法名字，没有方法的实施
public void B(){}//普通方法
}
//继承了抽象类的子类，如果要调用抽象类中的方法（抽象方法或普通方法），要重写这个方法
public class Test11 extends Test10 {
/*Test10 test10 = new Test10();*///抽象类不能new,会报错
@Override
public void A() {
}
}
存在的意义：提高开发效率
（有点类似C语言中把每个方法名都列出来那样）
（九）接口 interface
接口不能被实例化，接口中没有构造方法；
implements可以实现多个接口，必须要重写接口中的方法。
package com.TEST.JieKou;
//interface定义的关键字，接口都需要有实现类
public interface UserService {
//常量 public static final(可隐藏)
int age = 99;
//接口中所有定义的方法其实都是抽象的public abstract
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
package com.TEST.JieKou;
public interface TimeService {
}
package com.TEST.JieKou;
//类 可以实现接口 implements 接口
//实现接口的类需要重写类中的方法
//可以利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService {
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
}
（十）内部类
- 成员内部类
- 静态内部类
- 局部内部类
- 匿名内部类
五、异常
（一）捕获异常：try、catch、finally
try{
}catch(Exception e){
}finally{
}
public class Test01 {
public static void main(String[] args){
int a = 1;
int b = 0;
//假设想要捕获多个异常，要从小到大捕！
//可以用Ctrl+Alt+T选择try,catch代码块
try{//try监控区域
System.out.println(a/b);
}catch(Error e){//catch(想要捕获的异常类型 e)捕获异常
System.out.println("Error");
}catch (Exception e){
System.out.println("Exception");
}catch (Throwable t){
System.out.println("Throwable");
}finally {//finally处理善后工作，可以不要finally，
System.out.println("报错");
}
}
}
（二）抛出异常：throw、throws
……
（三）自定义异常
……
其它
Date date = null;//date表示日期
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");//可以用于日期格式化
//输入信息：
Scanner scanner = new Scanner(System.in);
key = scanner.next();
//new 类（）.方法();
new View().mainMenu();