java零碎

一、java基础

1、规则

2.常量 大写

3.关键字小写

4.标识符不能是关键字

5.包名小写 类或接口 首字母大写

6.方法，变量 第一个单词小写，第二个单词首字母大写

7.static没有创建类对象情况下。任然可以运行

8.变量 先定义，后赋值 int x，int y x=14 y=8

9.赋值运算符 c+=a 等于c=c+a c*=b等于c*b

10.方法

形参：走个形式 数据虚假 实参：实际数据表

有返回值类型 无返回值类型 有参无返回值方法(参数构成的方法)

有参有返回值方法（数据灵活，操作结果）

只完成某个功能，代码中某些值不需要动，结果不需要操作-----无参无返回值方法
完成某个功能，代码中某些值不需要动，结果需要操作----无参有返回值方法 
     完成功能---无参无返回值类型方法
     结果需要操作---无参有返回值方法
     完成功能，代码中的值需要动，结果不需要操作---有参无返回值方法
     完成功能，代码中值需要动，结果需要操作---有参有返回值方法
     参数要和返回值类型一致

public static int getSum(int a, int b) {
    return a + b;
}

无参有返回值方法
求两个数的和

public int  sumWuYou(){
	int num1 = 10 ;
	int num2 = 20 ;
	int sum=num1+num2;
	return sum;		
}

有参无返回值方法
求两个数的和
参数：
  num1 整数数值1
  num2 整数数值2

public void  sumYouWu(int num1,int num2){
	int sum=num1+num2;
	System.out.println(sum);		
}

有参有返回值方法
求两个数的和
参数：
  num1 整数数值1
  num2 整数数值2

public int  sumYouYou(int num1,int num2){
	int sum=num1+num2;
	return sum;		
}

方法重载：在同一个类中，方法名字一样，参数个数或者类型不一样的一组方法

11.数组

由多个元素构成的一个整体，多个数据，数据类型必须一致

数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。

例如：水杯 小分子是元素，多个小分子，形成一杯水
例如：教室 多名学生形成一个教室 学生是元素

数组好处：给存储进来的元素自动进行编号

arr[0]=10;   10：就是元素1          11：元素2     12：元素3
arr[1]=11;     arr[0]自动排序加1的：数组0索引 
arr[2]=12;     arr[1]=11：数组1索引上的元素11

索引访问数组中的元素：

​ 数组名[索引]=数值，为数组中的元素赋值
​ 变量=数组名[索引]，获取出数组中的元素

数组练习

public static void main(String[] args) { 
	int[] arr = { 5, 15, 2000, 10000, 100, 4000 }; //定义变量，保存数组中0索引的元素
	int max = arr[0]; //遍历数组，取出每个元素
	for (int i = 0; i < arr.length; i++) {//遍历到的元素和变量max比较
   	 	//如果数组元素大于max
		if (arr[i] > max) { //max记录住大值
			max = arr[i]; 
		} 
	}
	System.out.println("数组最大值是:" + max（1000）); //索引4
}

12.字符数组

char[] arr = {'a', 'b', 'c', '4', '5'};//类似于单个英文字母

字符串数组//好比成语

 String[] arr = {"aaa", "bbb", "cccc", "ddd", "eee"};

13.面向对象

三大特征：封装 继承 多态

类是对象的抽象，是对一堆有共同的特点的事物的描述，是概念，定义。

对象是某类的具体体现，实例对象，有名有性完整的人。

先定义类，类去创对象，对象完成任务。

大众汽车—汽车类

黑猫，具体实例化对象—猫类

这个黑猫是这个类的一个对象

有名有性完整的人

public  class Person{

String  name；

int age；//name和age都是属性

}

Person（）{//构造方法  给属性赋值，好比灵魂，而不是光肉身

name="ZhangSan";

age=23

}

对象的创建及使用
//创建对象
类名 对象名 = new 类名();

​ Person p = new Person();//这就创建了一个Person对象

//好比 person是类 p是张三

​ //对象是证明这个类的存在

//调用属性和方法 好比 通过张三调个人资料
对象名.属性;
对象名.方法(); //张三的擅长

14.张三的全部资料

//创建Person对象       叫什么名字
		Person p = new Person();
		//查看p的年龄
		int age = p.age;
		System.out.println("年龄为：" + age);
		//修改p的年龄为20岁
		p.age = 20;
		System.out.println("修改之后的年龄为：" + p.age);
		//调用方法，查看p的所有属性
		p.show();

new Person().show();匿名对象，没有名字

定义一个类，可以有属性、方法、构造方法、成员方法等内容。这里的属性又叫做成员变量

成员变量：一个人的变化性，不停蜕变，不是死的

比如：

成员变量就是：小孩的年龄 成人的年龄，不确定性

15.封装pravite（自私的）

快递不打包，很容易损坏，而且客户隐私也无法保障；如果银行是开放的，不仅容易出错，还容易出现安全问题。所以，我们需要封装。

//保护人的利益，隐私，好比保镖 不暴露自己的弱点

//大众化的可访问 隐私的不能访问

protected 修饰时 ，允许子类调用 ， private修饰时， 阻止其他类创建该类的对象

//protected 只能直系访问自己的隐私

隐藏类的 实现细节，对外暴露 公共的 访问方式（set和get方法）

公开：public

私密：private

部分：default

16.this关键字

this，就是自己，this所调用的，就是自己的东西

//this我自己拿我自己的东西

17.定义Student封装类

//一个完整的Student（学生类），封装后如下
public class Student {
    private String name;//姓名
    private int age;//年龄
    private String major;//专业

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public int getAge() {
    return age;
}

public void setAge(int age) {
    if (age > 0) {//加一个判断，更严谨
        this.age = age;
    }
}

public String getMajor() {
    return major;
}

public void setMajor(String major) {
    this.major = major;
}

public void study() {
    System.out.println(this.name + "在学习");//输出：XX在学习（这里的XX就是当前调用方法的学生的名字）
}
}

调用Student类；

//封装：也就是一个人可以有很多不同的个性化特点和技能

     Student stu = new Student();//构造一个Student对象
        stu.setName("小明");
        stu.setAge(18);
        stu.setMajor("物联网");
        System.out.println("学生的名字是："+stu.getName());
   stu.study();//调用study方法

创建小明这个相当于有参构造{public Person(int age,float height,String name)}

Person person4 = new Person(“小明”,150);

构造方法//好比出生婴儿

分为有参构造和无参构造//好比取名字，上户口，买衣服

​ 作用：创建对象

​ 创建对象执行对应的构造方法

​ 完成类的初始化(给成员变量赋值化）

标准封装类的编写（好比完整的一个什么都有的正常人）

私有化成员变量（个性化特点），提供公共的访问方式（多和别人交流）提供方法（一个人必备技能）空参构造（备用，防止出意外），全参构造

18.继承关系也就是多态的一种体现

super（）;用于继承关系//用父类的一切东西

super用法

​ a. super()调用——父类构造器。

​ b. super.方法()——调用父类方法。

​ c. super.属性——调用父类属性。

继承中的关系

子类继承父类，调用属性流程

首先在子类局部范围找。

然后在子类成员范围找。

最后在父类成员范围找

构造方法的关系

子类中所有构造方法默认访问父类中空参数的构造方法

子类继承父类的数据，还会使用父类的数据，，子类初始化前，一定要确保完成父类所有数据的初始化

注意！！！继承关系中，子类继承父类，只要每一个构造方法第一条默认初始化数据都是super

//子类可以继承父类的所有优点，子类还可以更完美

19.多态（感觉人的不同情绪不同表现）

多态格式 父类类型 变量名=new 子类对象

变量名.方法名（）

表现形式：继承或实现

​ 方法必须重写（不重写，无意义）

父类类型：子类对象继承的父类的类型，或实现父接口类型

Fu f=new Zi()

f.method()

多态成员特点：多态调方法时，检查父类中是否有此方法，没有，报错

有，执行子类重写后方法

定义父类//一类事物中，能证明该类的方法

public abstract class Animal {
	public abstract void eat();
}

定义子类//除了说明是一类事物，还有自己的个性化方法

class Cat extends Animal {
	public void eat() { 
		System.out.println("吃鱼"); 
	}
}


class Dog extends Animal {
	public void eat() { 
		System.out.println("吃骨头");
	}
}

向上转型：黑猫本来就是猫

向下转型：豹（特别声明也是猫类）

使用向上转型：Animal a=new Cat()

使用向下转型格式：Cat c=(Cat) a;

20.抽象类：
不需要实例化对象的任何证明（空口无凭）

abstract写在class前

抽象方法：abstract写在修饰符后，比如public abstract void 方法名 ()

抽象类的特点：

不能被实例化

有抽象方法才是抽象类，抽象类不一定有抽象方法

抽象类子类

普通类----完全实现父类的抽象方法

抽象类----没完全实现父类的抽象方法

抽象类成员

抽象类的构造器只用于子类访问父类数据的初始化功能

抽象类的成员与普通类的成员一致，只是抽象类中多了一个抽象方法

抽象方法使用可以强制子类完成某些动作，也可以使用普通方法提高代码复用性

抽象只对对象使用，不能和private static final关键字一起使用

共同体行为为：父类

（小狗小猫是动物类，抽象出父类Animal，不同动物不同吃的行为，父类对方法抽象化）

共同体行为的不同行为为：子类

子类继承父类，重写方法，实现不同需求

（子类继承父类，重写抽象方法，实现动物不同吃的食物不同的需求）

21.接口（扩展功能）

具备特殊独一无二额外技能的。接口与类之间关键字：implements

接口多态：接口由具体子类实例化

接口子类：要么为抽象类，要么重写接口中的所有抽象方法

类，接口等的区别

类与类之间是单继承，也可以多层继承（族谱）

类与接口可以单实现，也可以多实现，还能继承同一个类同时实现多个接口

同时实现多个接口，接口和接口之间 “，”逗号隔开

接口与接口之间：继承关系，可以单继承，也可以多继承

抽象父类：祖先的企业，由实现类继承

接口：任意位置添加，对类，接口功能是扩展

abstract class和interface有什么区别
两者都是抽象类，都不能实例化。
interface实现类及abstrct class的子类都必须要实现已经声明的抽象方法
interface需要实现，要用implements
abstract class需要继承，要用extends。一个类可以实现多个interface，但一个类只能继承一个abstract class。interface强调特定功能的实现，而abstract class强调所属关系。

抽象类和接口：
1、抽象类：abstract修饰符的class即为抽象类，abstract 类不能创建实例对象。有abstract方法的类必须定义为abstract class，abstract class类中的方法不一定是抽象的，也有普通的。abstract class类中定义抽象方法必须在具体(Concrete)子类中实现，所以不能有抽象构造方法或抽象静态方法。如果子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类型。
2、接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。
而接口主要是为了代码复用与功能的扩展；
3：一个类可以实现多个接口，而只能继承一个抽象类。并且抽象类中可以有静态方法，普通成员变量和构造方法，而接口中不可以；

Type与Class的区别：
首先Type是Class的父接口。而Class是Type的子类。
其次Type是Class的父接口。
Type可以表示出泛型的类型，而Class不能
Type 是 Java 编程语言中所有类型的公共高级接口。它们包括原始类型、参数化类型、数组类型、类型变量和基本类型。

22. 包：
就是不同的文件夹

打包：package   com.jiyun.chouxiang;    编译后代码自动放入这个包名里

23.内部类：

通过外部类调里面的具体一个类去实现功能

比如：工具箱平时需要的工具都放里了，但是当工具箱被使用于具体场景，比如拧螺丝，肯定会打开工具箱找出里面的螺丝刀，然后去使用螺丝刀，假设工具箱是一个类，将螺丝刀比作它里面的类，这就构成 内部类

内部类特点：

内部类是外部类的一个成员，内部类自由访问外部类成员

内部类声明静态，不能访问外部类成员了，此时内部类只能访问外部类的静态成员（静态访问静态）

面向对象：其实对象是类的抽象概念 ，也就是起一个名字，我们可以按照各种不同的功能，方法，模块，业务逻辑等分别起名，分别归类，使用此对象名调用该对象所代表的类中的不用函数也就是代码块，其中就是我们分开写的各种不同的方法，业务了逻辑等。
优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统 更加灵活、更加易于维护
缺点：性能比面向过程低

面向过程：其实就是在一个类中将所有的模块、功能、业务逻辑等按照执行顺序依次从上到下的书写并执行。
优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;
缺点：没有面向对象易维护、易复用、易扩展；