JAVA基础知识(黑马java笔记)

jdk

基础知识

注释

单行注释 //
多行注释/**/
文档注释/***/

关键字

Java赋予特殊含义的单词

字面量

数据在代码中的书写格式

标识符

给类，变量，方法取名字的一些符号
1.给变量命名
小驼峰命名法
2.给class命名
大驼峰命名法

数据类型

1.引用数据类型
2.基本数据类型
	整数
			byte，short,int ,long
	浮点数
			float，double
	字符
			char
	布尔
			boolean

scanner

Java核心类库里面封装的java源码用于输出

import java.util.Scanner;  //导入包
  
public class Scannertext {  
public static void main(String[] args) {  
Scanner sc=new Scanner(System.in);  //创建对象
System.out.println("请输入你的姓名");  
String name=sc.next();  //使用
System.out.println("请输入你的年龄");  
int age=sc.nextInt();  
System.out.println("请输入你的身高");  
double height=sc.nextDouble();  
System.out.println("请输入你的性别");  
String gender=sc.next();  
System.out.println("请输入你的婚姻状态");  
boolean status=sc.nextBoolean();  
}  
}

运算

运算符

1.基本运算符
	+ - x 
	/ ---整数相除只能得到整数
	% ---取余，判断奇数偶数
2.自增自减运算符
	++ --，注意放在变量前面或者后面
3.赋值运算符
	扩展的赋值运算符，自带强转效果、

4.关系运算符
	运算之后的结果为boolean类型

5.逻辑运算符

6.三元运算符
	int c= a>b ? a :b
7.运算符优先级

字符串拼接

当+遇到字符串的时候，+不是运算符，成为字符串拼接符

隐式转换

强制转换

进制

进制的分类

进制的转换

原码反码补码

计算机中的运算 --数字的二进制补码进行运算

方法（函数）

1.有返回值的函数
2.没有返回值的函数

3.方法重载

数组

package Day01;
//import java.util.
public class ArrayPractice {
    public static void main(String[] args) {
        //数组的静态初始化--指定数组元素

        int arr1[]=new int []{0,1,2};
        int[] arr2={3,4,5};

      
        //数组的动态初始化--只指定数组长度
        int []arr=new int[3];

    }
}

package Day01;

public class Array2 {
    public static void main(String[] args) {
        /*二维数组*/
        //1.静态初始化
        int [][]arr1=new int[][]{{1,2,3},{4,5,6}};
        int [][]arr2={{1,2,3},{4,5,6}};

        //2.动态初始化
        int [][]arr=new int[2][3];

        arr[0]=new int []{11,22,33};
        arr[1]=new int []{44,55,66};

        for(int i=0;i<2;i++)
        {
            for(int j=0;j<3;j++)
            {
                System.out.println(arr[i][j]);
            }
        }
    }
}

类和对象基础

设计对象

基础

1.java中创建对象必须要有类得存在
2.类
	一组属性与行为得集合，看作对象的设计图
3.对象
	根据类（设计图），创建出来的实体
4.类与对象的关系
	4.1 依赖关系：根据类创建对象
	4.2 数量关系：根据一个类可以创建多个对象

类的组成

类的本质：
	就是对事物进行的描述
1.属性--名词的描述（姓名，年龄）
	使用成员变量表示，位置处于类中方法外
2.行为--动词的描述（吃饭，看电视）
	使用成员方法表示，去掉static关键字

package com.mycode.opp;  
  
public class Student {  
//属性：设计图  
String name;  
int age;  
  
//行为  
public void study()  
{  
System.out.println("学生学习");  
}  
public void eat()  
{  
System.out.println("学生吃饭");  
}  
  
}

使用对象

* 创建student类的对象进行使用  
	* 1.创建对象的格式  
	* 类名 对象名 = new 类名（）；  
	* 2.使用对象成员变量的格式  
	* 对象名.成员变量  
	* 3.使用对象成员方法的格式  
	* 对象名.成员方法()  
* 细节：  
	* 打印对象名，看到对象成员的地址  
	* com.mycode.opp.Student@3b07d329  
	* 成员变量就算没有赋值，也可以直接用，使用的是对象的默认值  

package com.mycode.opp;  
  
//测试类含有主方法  
public class StudentTest {  

public static void main(String[] args) {  
Student stu1=new Student();  
System.out.println(stu1);  
  
System.out.println(stu1.age);  
System.out.println(stu1.name);  
  
stu1.eat();  
stu1.study();  
System.out.println("----------");  
  
Student stu2=new Student();  
System.out.println(stu2);  
  
System.out.println(stu2.age);  
System.out.println(stu2.name);  
  
stu2.eat();  
stu2.study();  
}  
}

成员变量与局部变量的区别

this关键字

构造方法

• 构造方法（构造器）：
  • 创建对象的时候，要执行的方法
• 格式：
  • 1.方法名与类名相同
  • 2.没有返回值类型，连void也没有
  • 3.没有具体返回值（不能使用return语句）
• 构造方法执行时机：
  • 创建对象的时候执行
  • 每创建一次对象，就会执行一次
• 作用：
  • 本质作用-创建对象
  • 在创建对象的时候可以对对象中的数据进行初始化
    

package com.mycode.constructor;  
  
public class Student {  
//属性  
String name;  
int age;  
//构造方法  
public Student(String name,int age)  
{  
this.name=name;  
this.age=age;  
System.out.println("我是Student类构造方法");  
}  
  
}

package com.mycode.constructor;  
  
public class StudentTest {  

public static void main(String[] args) {  
//去掉前面的，Student（）调用构造方法  
Student s1=new Student("Alice",17);  
System.out.println(s1.name+s1.age);  
  
}  
  
}

封装

权限修饰符

private：
	同一个类中访问
（default）：同一个类中，同一个包中（默认）
protected：
	同一个类中。同一个包中，不同包的字类
public
	任意位置访问

设计规范

合理隐藏，合理暴露

package com.mycode.fengzhuang;  
/*  
* 给私有成员变量
* 通过公共的行为方法来赋值及返回值操作  
* */  
public class Student {  
private int age;  
  
public void setAge(int age)  
{  
this.age=age;  
}  
  
public int getAge()  
{  
return age;  
}  
}

javaBean—实体类

1.该类中只写成员变量
2.写空参和带有实参的两个构造函数
3.给对应的成员变量写setXXX与getxxx函数---有快捷键

只负责数据存取
对数据的处理交给其他类来完成

package com.mycode.fengzhuang;  
/*  
* 给私有成员变量赋值及返回值操作  
* */  
public class Student {  
private int age;  
private String name;  
  
  
public Student() {  
}  
  
public Student(int age, String name) {  
this.age = age;  
this.name = name;  
}  
  
/**  
* 获取  
* @return age  
*/  
public int getAge() {  
return age;  
}  
  
/**  
* 设置  
* @param age  
*/  
public void setAge(int age) {  
this.age = age;  
}  
  
/**  
* 获取  
* @return name  
*/  
public String getName() {  
return name;  
}  
  
/**  
* 设置  
* @param name  
*/  
public void setName(String name) {  
this.name = name;  
}  
  
  
}

字符串

API（application programming interface）

应用程序接口
即别人写好的一些类，自我调用就可以

jdk API 帮助文档
先查找到类
看包
若在java.lang中，则直接使用
若不在，要用导包代码导入包
看类的构造方法
创建该类
看类的成员方法

字符串

• Scanner键盘录入：
  • String next(): 遇到空格或者tab键就不在录入
  • String nextline():以回车作为录入结束标识
• string 类的特点：
  • 1.java中所有双引号的字符串，都是String类的对象
  • 2.字符串在创建后其内容不可改变
  • 3.字符串虽然不可改变，但是可以被共享（字符串常量池）
    *string 类的构建:
  • 1.直接双引号构建
  • 2.通过构建方法构建
    *string 类的构造方法：
  • public String():直接构造空白字符串
  • public String(char[] chs):根据传入的字符数组来创建字符对象
  • public String(Strting original):根据传入的字符串创建字符串对象
• 问题：
  • 打印对象名，应该输出地址
  • 这里打印字符串对象名,未得到地址

package com.mycode2.scanner;  
  
import java.util.Scanner;  
  
public class ScannerDemo {  

public static void main(String[] args) {  
// Scanner s1=new Scanner(System.in);  
// System.out.println("输入一个数字");  
// int num=s1.nextInt();  
// System.out.println("输入字符串");  
//  
// String name=s1.nextLine();  
// System.out.println(name);  
  
String a=new String();  
System.out.println(a);  
  
char []chs={'1','2','3'};  
String b=new String(chs);  
System.out.println(b);  
  
String c="adff";  
System.out.println(c);  
String d=new String(c);  
System.out.println(d);  
  
}  
}

字符串常用方法

package com.mycode2.StringWays;  
  
public class MyStringWay {  
public static void main(String[] args) {  
String s1="swwe";  
String s2="srwe";  
String s4="sWWe";  
String s3=new String(s1);  
System.out.println(s1==s2);  
System.out.println(s1==s3);  
  
  
/*比较函数：*/  
System.out.println(s1.equals(s2));  
System.out.println(s1.equals(s4));  
System.out.println(s1.equalsIgnoreCase(s4));  
  
/*字符串遍历函数*/  
char []s=s1.toCharArray();//转换为字符数组  
for (int i = 0; i < s.length; i++) {  
System.out.println(s[i]);  
}  
System.out.println(s1.charAt(0));//根据索引找字符  
System.out.println(s1.length());  
/*切割*/  
System.out.println(s1.substring(2));  
System.out.println(s2.substring(1, 2));  
System.out.println(s1.replace(s1, s4));  
/*  
* we  
r  
sWWe  
* */  
String[]ww= s1.split("ww");  
for (int i = 0; i < ww.length; i++) {  
System.out.println(ww[i]);  
}  
  
}  
}

StringBuilder

stringbuilder作用：

• 提高字符串的操作效率

package com.mycode2.stringBuilder;  

public class StringBuilderDemo {  
public static void main(String[] args) {  
// method(); 3014ms  
// long start=System.currentTimeMillis();  
// StringBuilder sb=new StringBuilder();  
// for (int i = 0; i <100000 ; i++) {  
// sb.append(i);  
// }  
// System.out.println(sb);  
// long end=System.currentTimeMillis();  
// System.out.println(end-start); 16ms  
}  
public static void method()  
{  
  
long start=System.currentTimeMillis();  
String s="";  
for(int i=0;i<100000;i++)  
{  
s+=i;  
}  
long end=System.currentTimeMillis();  
System.out.println(end-start);  
}  
  
}

• String Builder介绍：
  • 1.一个可变的字符序列
  • 2.是字符缓冲区，可以理解为容器，可以存放任意类型的数据，但是只要进入这个容器，全变成字符串
• StringBuilder的构造方法：
  • StringBuilder sb=new StringBuilder();//空参构造
  • StringBuilder sb2=new StringBuilder(“123”);//带参构造
• Stringbuilder常用方法：
  • sb.append(123);
  • sb.reverse()
  • sb.length()
  • sb.toString()

package com.mycode2.stringBuilder;  
  
public class StringBuilderDemo2 {  

public static void main(String[] args) {  
StringBuilder sb=new StringBuilder();//空参构造（不够时会自动扩容）  
StringBuilder sb2=new StringBuilder("123");//带参构造  
System.out.println(sb2);  
  
System.out.println("______");  
//常用方法  
sb.append(123);  
sb.append("sffg");  
sb.append(23.44);  
System.out.println(sb);  
  
System.out.println(sb.reverse());  
System.out.println(sb.length());  
//调用的方法StringBuilder没有，但是String有，转换成String  
char[] s2=sb.toString().toCharArray();  
for (int i = 0; i < s2.length; i++) {  
System.out.println(s2[i]);  
}  
}  
}

集合

• 集合介绍：
  • 可变数组，当数组大小不够时，自动扩容为原大小1.5倍的
  • 可能会造成内存的浪费
• 集合的使用：
  • 1.构造方法：
  • public ArrsyList():创建一个空的集合容器
  • 2.创建细节：
  • 可以添加任意类型数据，数据不够严谨—添加<>指定数据类型
  • <>:泛型
  • 1.使用泛型可以对集合中储存的数据进行类型的限制
  • 2.泛型中不限制基本数据类型----解决方案：使用基本数据类型所对应的包装类
  • int—Interger
  • char–Character
  • short–Short
• 集合的常用方法：
  • 1.增加：
  • list.add(e)—将指定元素添加到列表的末尾
  • list.add(index,e)----将指定元素添加到指定位置
  • 2.删除
  • list.remove(index)----根据索引删除，返回删除的元素
  • list.remove(item)----根据内容删除，返回是否删除成功
  • 3.修改
  • list.set(index,item)—根据索引修改，返回被修改之前的元素
  • 4.查询–返回值一般会接收
  • list.get(index)
  • list.size()

package com.mycode2.arraylist;  
  
import java.util.ArrayList;  
  
public class ArrayListDemo {  

public static void main(String[] args) {  
addMthod();  
removeMethod();  
setMetuod();  
getMrthod();  
}  
public static void addMthod()  
{  
ArrayList<String> list=new ArrayList<>();  
list.add("ssdff");  
list.add("sddff");  
list.add(1,"dee");  
System.out.println("添加后"+list);  
}  
public static void removeMethod()  
{  
  
ArrayList<String> list=new ArrayList<>();  
list.add("ssdff");  
list.add("sddff");  
list.add(1,"dee");  
// String re= list.remove(1);  
list.remove("dee");  
System.out.println("删除后" +list);  
// System.out.println("删除的是"+re);  
}  
public static void setMetuod()  
{  
ArrayList<String> list=new ArrayList<>();  
list.add("ssdff");  
list.add("sddff");  
list.add(1,"dee");  
list.set(1,"张三");  
System.out.println("修改后为"+list);  
}  
public static void getMrthod()  
{  
ArrayList<String> list=new ArrayList<>();  
list.add("ssdff");  
list.add("sddff");  
list.add(1,"dee");  
System.out.println("查询"+list.get(1));  
System.out.println("长度"+list.size());  
}  
}