1、alt+shift+up/down

     ctrl+D

2、Java基本类型：char    boolean  short  float   double  long   byte   int

      引用类型：除以上别的所有类型都是引用类型

      数组一旦被定义，大小就确定了，无法更改

3、OOP：object oriented programming

类，对象，方法，属性，构造函数

1、类：抽象的不具体存在的，描述同一类实物（具有共同属性和方法），不能完成具体              的事。

            类就是封装。

                  定义一个类，通常情况下一个文件对应一个类

                  修饰符：public  static  final

                  修饰符 class 类名{

                 这个类的一些属性：成员变量（存什么值）

                 这个类的功能：方法（完成什么功能）

                 }

2、 对象：java中除了8大基本数据类型外，别的都是对象

                具体的，实际存在的，某一类的事例化

                对象都是new出来的

      对象一旦创建属性变量就有初值：char:' ' ;    int,long,short:0  ; 

      同一个类可以创建多个对象，每个对象的内存空间都是独立的（对象之间没有任何关        系），对一个对象属性操作不影响另一个

      只用一次的对象可以没有名字，称为匿名对象

3、方法的定义：public  static  final  private

      方法的使用：调用谁（哪个对象）的方法，在类里面可以直接调用自己的方法，在外                             部必须通过对象来调用

      在自己的类里可以调用这个类所有方法

      调用方法中有多个参数时，用逗号隔开

4、封装：把私有的东西封装起来，不让外部使用

需要给外部使用时暴露出来

访问权限：public：公共的，内外部都可以用

                 private：私有的，只能自己使用，外部无法访问

                 protected：受保护的，外部（同一个包里）可以访问

继承

多态

实例

1、/**

* Scanner

* Random

* Java实现一个通讯录

* 1.索引 -> 查找对应的字母下面的联系人

* 2.添加联系人

* 3.删除联系人

*

* OOP(Object oriented programming)

*

* 类：Contact：【姓名 地址 email 电话号码】

*     byte char boolean short int long double float

*     java里面除了8大基本数据类型之外 都是对象

*     抽象的 不实际存在 描述同一类实物（具有共同的属性和方法）

*     人类：概念 抽象 不能完成具体的事情

*     小王：对象 具体存在 可以使用的

*

*     车子：牌子 四个轮子 发动机 5个座位 不可以开

*     宝马：BMW 四个轮子 发动机 5个座位 可以开

*     奔驰：

*     奥迪

*

*     类就是封装

* 对象

*      具体的，实际存在的，某一类的实例化

*      对象都是new出来的

*      可以完成具体的事情，有内存空间的

*      同一个类可以有多个对象

* 属性

* 方法

* 构造函数

*/

class TestClass{

public static void main(String[] args){

/*

创建Person类的一个对象 new

使用.访问成员变量

对象一旦创建 属性变量有初值

char '' int long short 0

float double 0.0 byte 0

boolean false

引用数据类型：对象类型的变量 = null

*/

Person xw = new Person();

Person zs = new Person();

/*

同一个类可以创建多个对象

每个对象的内存空间都是独立的（对象之间没有任何关系）

xw和zs除了都是通过一个类创建的之外 没有任何关系

对xw的属性进行操作 不会影响zs

*/

//给这个对象对应的属性赋值

xw.name = "小王";

xw.age = 20;

xw.score = 86.5f;

System.out.println(xw.name);

System.out.println(xw.age);

System.out.println(xw.choice);

/*

方法的使用

调用谁(哪个对象)的方法

在类里面可以直接调用自己的方法

在外部必须通过对象来调用

*/

//        Random random = new Random();

//        random.nextInt();

//

//        Scanner scanner = new Scanner(System.in);

//        scanner.nextInt();

Person lisi = new Person();

lisi.test();

//匿名对象 -> 作为一个参数传递

int result = lisi.test6(new int[]{1, 2, 3, 4, 5});

System.out.println(result);

}

}

/**

* 定义一个类 通常情况下一个文件对应一个类

* 修饰符：public static final

*

* 修饰符 class 类名{

*     这个类的一些属性：成员变量

*     这个类的功能：方法

* }

*/

/**

* 1.存什么值 ：成员变量

* 2.完成什么功能：方法

*/

class Person{

//成员变量 定义在类的最上面

String name;

int age;

float score;

String password;

char choice;

//方法的定义 public static final private

public void test(){

System.out.println("没返回值 没参数的方法");

}

public void test2(){

//在自己的类里面可以调用这个类里面的所有资源

//this.test();

test();

}

//没有返回值 接收一个参数

public void test3(String name){

}

//有一个参数一个返回值

public int test4(String name){

return 0;

}

//有多个参数 每个参数用逗号隔开

public int test5(String name, int age){

return 0;

}

//可变参数 相当于 数组

public int test6(int ... counts){

int sum = 0;

for (int i = 0; i < counts.length; i++){

sum += counts[i];

}

return sum;

}

}

2、//自定义控件、消息

class GuessNumber{

public static void main(String[] args){

//保存原始数字

int[] org = new int[4];

//保存用户猜测的数字

int[] guess = new int[4];

//产生4个随机数

Random random = new Random();

for (int i = 0; i < 4; i++){

//产生一个随机数

int temp = random.nextInt(10);

//判断是否存在

boolean result = contains(org, temp);

if (result){

//确保i对应的位置能够得到一个不重复的数字

i--;

}else{

org[i] = temp;

}

}

//排序

Arrays.sort(org);

System.out.println(Arrays.toString(org));

//定义一个扫描仪对象Scanner

Scanner scanner = new Scanner(System.in);

//开始游戏

while(true){

int countA = 0;

int countB = 0;

System.out.print("请输入猜测的数字:");

for (int i = 0; i < 4;i++){

guess[i] = scanner.nextInt();

}

//判断用户输入

//1.判断是否存在

for (int i = 0; i < 4; i++) {

boolean result =contains(guess, org[i]);

if(result == true){

//数字存在

//判断位置是否相同

int index = indexOf(guess, org[i]);

System.out.println("i:"+i+" index:"+index);

if (index == i){

//数字和位置都相同

countA++;

} else{

countB++;

}

}

}

if (countA == 4){

System.out.println("恭喜全对!");

break;

}else{

System.out.println(countA+"A"+countB+"B");

}

}

}

/**

* 在一个数组里面查找某个对象的索引值

* @param val 数组

* @param obj 查找的对象

* @return 索引值

*/

public static int indexOf(int[] val, int obj){

for (int i = 0; i < val.length; i++){

if (val[i] == obj){

return i;

}

}

return -1;

}

//自己写一个方法实现 判断某个数组里面是否包含某个值

public static boolean contains(int[] val, int obj){

for (int i = 0; i < val.length; i++){

if (val[i] == obj){

//重复了

return true;

}

}

return false;

}

}

感悟

不要放弃，每天进步一点点