1， 单词：
Visible 可见物，field 字段assignment:分配，任务 constructor构造器 duplicate重复 outline 轮廓，大纲 paramater参数access访问修饰符 volume；容积 context 环境，上下文 instance 实例 argument；参数争论 mobile 可移动的
键盘录入：int型：sc.nextInt String型：sc.next()。
2， 快捷键:
Ctrl+shify+o:自动导包
Alt+shift+s:
+0:表示产生构造方法
+r:产生getxx setxx(tab键+回车+tab(4下)+回车)
+s,产生toString
类：
类是一组具有相关的属性和行为的集合。
类的组成
* （1）成员变量
* （2）构造方法
* （3）成员方法
* （4）getxx setxx
* 属性：成员变量
* 行为：成员方法
* 定义类的过程，就是编写成员变量和成员方法的过程。
3.访问修饰有：modifier:private public protected(default)
4，构造方法
* （1）作用：
* 给类的成员变量初始化或者赋值用的。
* （2）格式：
* 方法名和类名相同
* 构造方法没有返回值类型，连void也不用写
* 构造方法没用返回值，可以不写return
* (3)构造方法的特点
* 如果类中，没用提供任何构造方法，系统（虚拟机）会提供一个无参的构造方法
* 如果类中，提供了构造方法，系统（虚拟机）将会不再提供无参的构造方法
*构造方法可以重载
* 总结有2种方式来修改成员变量的值
* （1）构造方法
* （2）通过setxx方法（特殊的成员方法）
*
5,打印对象，就是调用对象的toString()方法就是不会在控制台输出地址值。
6，this关键字的作用
* this表示：当前对象的引用
* 使用场景:
* (1)局部变量和成员变量重名
7，类的构造方法什么时候被调用
student stu=new student("","",20);//创建对象之后，立刻调用了构造方法，来对对象的成员变量进行初始化
//方案一创建一个对象之后，立刻调用该类的构造方法，对当前对象，进行成员变量的初始化
8，匿名对象
calculator calc=new calculator();
method1(calc);//需要一个实际参数
/*
* 匿名对象，没用名字的对象
* */
new calculator();//定义了一个匿名对象(只在当前行有效)
//级联调用：
//匿名对象的场景：（1）作为方法的实际参数传递的时候
//（2）只调用成员方法或成员变量一次的时候
//好处：提高了堆内存的使用效率，加快了回收速度。
method1(new calculator());//匿名对象作为实际参数
(new calculator()).add();//匿名对象调用成员方法只有一次，也就是用一次就消失了。
，9，演示成员变量和局部变量的区别
*@author jerry
*
*/
public class MemberVariable {
//成员变量
//在类里面，在方法外，可以定义成员变量
staticint x = 100;
inti = 200;
publicstatic void main(String[] args) {
//定义局部变量,在方法内定义
inti = 10;
intz ; //只定义，没有赋值
//当成员变量和本地变量，同名时，到底调用哪个呢？ 作用域和就近原则
//本地变量 or 局部变量
System.out.println(i);
z= 20;
//Thelocal variable z may not have been initialized
System.out.println(z);
//在类自己的方法内，能不能使用成员变量呢？ 必须能
System.out.println(x);
}
}
10，基本数据类型作为形式参数传递
@author jerry
*
*/
public class PrimitiveTypeDemo {
publicstatic void main(String[] args) {
inta = 10;
intb = 20;
//调用方法
intsum = add(a,b);
System.out.println("输出方法结果："+sum);
//通过对象的形式调用
Calculatorcalc = new Calculator();
//调用对象的成员方法
sum= calc.add(a, b);
System.out.println("调用对象的成员方法的结果："+sum);
//调用对象的成员方法
calc.num1= a;
calc.num2= b;
sum= calc.add();
System.out.println("调用对象的成员方法并且不传递值的结果："+sum);
}
/**
* 基本数据类型作为形式参数
* @param a
* @param b
* @return
*/
publicstatic int add(int a ,int b){
returna +b;
}
}
11，演示 引用类型 （自定义的类类型）作为方法的形式参数传递
*/
public class ReferenceTypeDemo {
publicstatic void main(String[] args) {
//定义一个本地变量（对象）
Calculatorcalc = new Calculator();
//调用方法
method1(calc);//需要一个实际参数
//匿名对象，就是没有名字的对象
//定义了一个匿名对象
newCalculator();
method1(newCalculator());//匿名对象作为实际参数
// calc.add();
//级联调用的概念
Calculatorcalc1 = new Calculator();
calc1.add();
(newCalculator()).add();//匿名对象调用成员方法 只有一次
(newCalculator()).add();//匿名对象调用成员方法 只有一次
}
/**
* 引用类型（自定义类型）作为方法的形式参数出现
* @param calc
*/
// publicstatic void method1(int[] array){
publicstatic void method1(Calculator calc){ //形式参数
//任意定义两个数
inta = 10;
intb = 20;
//给对象的成员变量赋值
calc.num1= a;
calc.num2= b;
//调用对象的成员方法
intsum = calc.add();
System.out.println("结果为："+sum);
}
}
12，一个自定义类（学生类）的标准的写法
* @author jerry
*
*/
public class Stu {
// 成员变量
private Stringname;
private Stringgender;
private intage;
// 成员方法
// 赋值给成员变量name
public voidsetName(String name) {
//Theassignment to variable name has no effect
this.name= name;
/**
* this 关键字的作用：
* this表示：当前对象的引用，
* 使用场景：
* 1： 局部变量和成员变量重名的时候。
*/
}
// 将成员变量name的值，返回
public StringgetName() {
returnname;
}
public voidsetGender(String myGender) {
gender =myGender;
}
public StringgetGender() {
returngender;
}
public voidsetAge(int myAge) {
age =myAge;
}
public intgetAge() {
returnage;
}
// 成员方法method
public voidstudy() {
System.out.println("study()");
method1();
// 在这里能不能访问 age ？ 能
}
public voidplay() {
System.out.println("play()");
method1();
}
public voidsleep() {
System.out.println("sleep()");
method1();
}
private voidmethod1(){
System.out.println("method1()");
}
}
13，准写法的测试代码
* 添加了private，并且封装性的体现
*/
public class StuDemo {
private int i= 10;
public voidmethod1(){
int i =10;
i =20;//本地变量or 局部变量
this.i =30;
}
public staticvoid main(String[] args) {
Stu stu =new Stu();
//赋值，只能通过setXXX()
stu.setName("jerry");
stu.setGender("male");
stu.setAge(20);
//读取成员变量的值
System.out.println(stu.getName());
System.out.println(stu.getGender());
System.out.println(stu.getAge());
}
}
14，典型例题
package com.newedu.jb.day07.exercise;
import java.util.Scanner;
/**
* 1:数据加密问题
某个公司采用公用电话传递数据信息，数据是小于8位的整数，为了确保安全，
在传递过程中需要加密，加密规则如下：
首先将数据倒序，然后将每位数字都加上5，再用和除以10的余数代替该数字，
最后将第一位和最后一位数字交换。 请任意给定一个小于8位的整数，
然后，把加密后的结果在控制台打印出来。
程序分析：
x= 123456
y = x;
y = 654321
6+5= 11%10=1
y = 109876
y = 609871
如何将任意一下整数 的每一个位值，放到数组中存储？
先对10进行取余，然后将数值直接除以10，重复计算
y = 654321
y%10 =1
y /=10; y=65432
...
数组中存储的整数的每一个位值，那么就可以很方面的进行，加减乘除求与
* @author jerry
*
*/
public class Exercise2 {
public staticvoid main(String[] args) {
//第一步:从键盘获取用户输入
Scannersc = new Scanner(System.in);
System.out.println("请输入一个整数值，必须是小于8位的");
//确保用户一定输入的值为整数类型
while(!sc.hasNextInt()){//表示输入的不是整数类型
System.out.println("输入的不是整数，请重新输入");
sc.next();
}
int num =sc.nextInt();
intoldNum = num;
System.out.println("用户输入的数字为：" +oldNum);
//第二步： 将用户输入的数字 存储到数组中。
//定义一个整型的数组，长度为8位，
int[]array = new int[8];
//我们如何确定输入的整数值，具体是几位呢？
//我们准备取整数的一个位数，然后放置到数组中
//假如num = 123456;
//取个位
// int g =num %10;
// num /=10;
// array[0] =g;
//取十位
// int f =num %10;
// num /=10;
// array[1] =f;
//...
//定义一个索引值,准备计算整数的长度
int index=0;
while(num!=0){
//求余，并且存放到数组中，索引按index计数
array[index]= num%10;
// 对原有的数进行求商处理
num/=10;
//索引计数
index++;
}
// 我们就得到了数组
//测试数组的内容
printArray(array);
System.out.println("整数的位数："+index);
//第三步：套用加密规则
for(inti=0;i<index;i++){
array[i]+=5;
array[i]%=10;
}
//交换第一个元素和最后一个元素
int temp= array[0];
array[0]= array[index-1];
array[index-1]= temp;
// printArray(array);
System.out.print("加密后的数字：");
for(inti=0;i<index;i++){
System.out.print(array[i]);
}
}
/**
* 定义一个循环打印数组元素的方法
* @param array 需要输出元素的数组
*/
public staticvoid printArray(int[] array){
// array 也是一个本地变量，只不过是printArray()方法中的本地变量。
System.out.print("数组的元素 ：[");
for(inti=0;i<array.length;i++){
// 判断当i等于最后一个元素的下标时，
if(i!=array.length-1){
System.out.print(array[i]+",");
}
else{
System.out.print(array[i]);
}
}
System.out.println("]");//输出并，换行
}
}
15，
代码块的概念
局部代码块：方法内定义，限制了变量的作用域，及早释放，提高内存利用率
* 构造代码块
* 静态代码块
（1）public class CodeBlockDemo1{
public staticvoid main(String[] args) {
int i =10;// 作用域在main方法里面
//局部代码块
{
inta = 20;// 提早释放
// inti = 20;
}
for(int j=0;j<10;j++){
}
}
}
（2）自定义类
* 演示构造代码块 和静态代码块
public class CodeBlockDemo2 {
//成员变量
private Stringname;
private intage ;
private staticString nationality;
//静态代码块 给类初始化，因为随着类的加载而加载,先于对象存在
static{
//name ="jerry";
//Cannotmake a static reference to the non-static field name
// name ="jerry";
System.out.println("静态代码块被执行了");
nationality= "中国";
}
// 构造代码块
{
System.out.println("进入构造方法了");
}
//构造方法
publicCodeBlockDemo2(){
// System.out.println("进入构造方法了");
System.out.println("CodeBlockDemo2()");
}
publicCodeBlockDemo2(String name) {
// System.out.println("进入构造方法了");
System.out.println("CodeBlockDemo2(String)");
this.name= name;
}
publicCodeBlockDemo2(int age) {
// System.out.println("进入构造方法了");
System.out.println("CodeBlockDemo2(int)");
this.age= age;
}
public CodeBlockDemo2(Stringname, int age) {
// System.out.println("进入构造方法了");
System.out.println("CodeBlockDemo2(String,int)");
this.name= name;
this.age= age;
}
//成员方法
}
测试 构造代码块 的测试类
* @author jerry
*
*/
public class CodeBlockDemo2Test {
public staticvoid main(String[] args) {
// 创建对象，调用类的无参构造
CodeBlockDemo2cbd = new CodeBlockDemo2();
System.out.println(cbd);
CodeBlockDemo2cbd2 = new CodeBlockDemo2("jerry", 20);
System.out.println(cbd2);
}
}
16，练习
package com.newedu.jb.day08.exercise;
import java.util.Scanner;
/**
*
* 猜数字小游戏(1-100之间的数字)
* 模拟用户名与密码的登录，只有三次机会。
*
* 假设用户名，密码为固定的值
* while,for循环来控制次数
* 用户每输入一次，就记录下来，
* 输入的用户名密码 与之前存在的用户名密码对比，判断是否相同
* @author jerry
*
*/
public class Exercise1 {
public staticvoid main(String[] args) {
//定义两个变量，来存储用户名，密码
StringuserName = "admin";
Stringpassword = "123456";
//还要在定义两个变量，来接收用户从键盘的输入的用户名，密码
Scannersc = new Scanner(System.in);
//ctrl+shift+o :自动的导入当前类中需要使用包名，自动导包
label1:for(inti=2;i>=0;i--){
System.out.println("欢迎登陆xx登陆，请提供用户名和密码！");
System.out.println("请输入用户名：");
//从键盘接收用户的输入，接收的类型为String类型
StringinputUserName = sc.next();
System.out.println("请输入密码：");
StringinputPassword = sc.next();
if(userName.equals(inputUserName)
&&password.equals(inputPassword)){
//表示，登陆成功，可以开始玩游戏
System.out.println("登陆系统成功，可以玩游戏了！");
//系统自动产生了一个随机数，让用户猜
//固定一个随机数 例如：49
intkey = 49;
while(true){//死循环
System.out.println("请输入一个整数：");
//为了确保用户输入的一定是整数
while(!sc.hasNextInt()){
System.out.println("输入的整数有误，请重新输入！");
sc.next();
}
//让用户输入一个数字
intnum = sc.nextInt();
if(num== key ){
System.out.println("恭喜你，猜对啦");
break label1;
}elseif(num> key){
System.out.println("大了，请重新猜！");
}else{
System.out.println("小了，请重新猜！");
}
}
}
else{
//继续登陆，而且记录次数，只有三次登陆机会。
if(i!=0){
System.out.println("用户名，密码输入错误，还剩下"+i+"次机会");
}else{
System.out.println("输入三次错误的用户名和密码，系统自动锁定该账号24小时！");
}
}
}
}
}
17，自定义一个数组的操作的工具类
要求，工具类，为了方法调用者使用，要求工具类中的所有方法，都是static的
* @author jerry
*
*/
public class ArrayTools {
//添加一个private的无参构造方法，为了抑制 jvm自动添加无参构造
private ArrayTools(){}
/**
* 使用选择排序，对数组进行从小到大的排序
* @param array 需要排序的数组
*/
public staticvoid selectSort(int[] array){
for(intj=0;j<array.length-1;j++){
for(inti =j+1;i<array.length;i++){
if(array[j]>array[i]){
inttemp = array[j];
array[j]= array[i];
array[i]= temp;
}
}
}
}
//私有的，本类自己的方法使用
private staticvoid swap(int[] array,int start,int end){
int temp= array[start];
array[start]= array[end];
array[end]= temp;
// 只有在引用数据类型（数组）情况下，才可以在方法内，改变有效
// 基本数据类型，改变 后，无法保存
}
/**
* 冒泡排序
* @param array 需要排序的数组
*/
public staticvoid bubbleSort(int[] array) {
//因为重复的代码过多，使用for循环来改进，所以两重for循环的嵌套
//外循环，控制循环的几轮
for(int j= 0;j<array.length-1;j++){
// 通过j，来控制每次比较的元素的个数
for(inti =0;i<array.length-1-j;i++){
//从第一个位置开始，相邻两个元素进行比较
if(array[i]>array[i+1]){
// inttemp = array[i];
// array[i] = array[i+1];
// array[i+1]= temp;
swap(array,i,i+1);
}
}
}
}
/**
* 定义一个循环打印数组元素的方法
* @param array 需要输出元素的数组
*/
public staticvoid printArray(int[] array){
// array 也是一个本地变量，只不过是printArray()方法中的本地变量。
System.out.print("数组的元素 ：[");
for(inti=0;i<array.length;i++){
// 判断当i等于最后一个元素的下标时，
if(i!=array.length-1){
System.out.print(array[i]+",");
}
else{
System.out.print(array[i]);
}
}
System.out.println("]");//输出并，换行
}
/**
* 折半查找
* @param array 目标数组，必须是有序的
* @param key 目标值，
* @return 返回的索引，如果找不到 返回-1
*/
public staticint halfSearch(int[] array, int key) {
//定义三个变量，
int min =0;
int max =array.length-1;
int mid =(min + max)/2;
int time= 1;
while(key!=array[mid]){//如果 key 不等于中间值，就一直比较下去
//大了
if(key> array[mid]){
min= mid +1;
// mid= (min+max)/2;
}else{//小了
max= mid - 1;
// mid= (min+max)/2;
}
mid= (min+max)/2;
//避免死循环的出现
if(min>max){
return-1;
}
time++;
}
System.out.println("比较了几次："+time);
returnmid;
}
}
18，*
* 测试ArrayTools工具类
*
*
*/
public class ArrayToolsDemo {
public staticvoid main(String[] args) {
int[]array = {5,7,13,2,9,11};
//通过类名的形式调用
ArrayTools.printArray(array);
ArrayTools.bubbleSort(array);
ArrayTools.printArray(array);
//为了杜绝调用者 使用对象名的形式调用,我们需要提供一个私有的无参构造
//The constructor ArrayTools() is notvisible
// ArrayToolsat = new ArrayTools();
Scannersc = new Scanner(System.in);
}
}
19，
,static关键字
自定义类型，人类型
* ststic 示意图
* 静态的随着类的加载儿加载，优先于对象的存在，因为this右表示当前对象，所以不能使用。
* 静态成员方法，只能调用静态的成员变量和方法
* 静态的方法，建议直接使用类名调用，虽然也可以通过对象名调用
* 非静态的成员方法，通过对象调用
关于静态的在内存中的示意图。
例如：
private String name;
privateintage;
privatestatic String nationality;
public person(String name, intage) {
super();
this.name = name;
this.age = age;
}
public person(String name, intage, String nationality) {
super();
this.name = name;
this.age = age;
this.nationality = nationality;
}
public String getName() {
returnname;
}
publicvoid setName(String name) {
this.name = name;
}
publicint getAge() {
returnage;
}
publicvoid setAge(intage) {
this.age = age;
}
person p1=new person("tom",20);
person p2=new person("susan",20);
person p3=new person("jerry",20);
System.out.println(p1);
System.out.println(p2);
System.out.println(p3);
System.out.println("=========");
person p4=new person("j1",20,"中国");
person p5=new person("j2",20);
person p6=new person("j3",20);
//打印对象，就是调用对象的toString方法
System.out.println(p4);
System.out.println(p5);
System.out.println(p6);
}
输出结果为
person [name=tom, age=20,nationality=null]
person [name=susan, age=20,nationality=null]
person [name=jerry, age=20, nationality=null]
=========
person [name=j1, age=20,nationality=中国]
person [name=j2, age=20,nationality=中国]
person [name=j3, age=20,nationality=中国]
20，this关键字总结：
4，Java中this关键字在构造方法中的使用
1. Java中this关键字代表对象本身。用this关键字可以在类的内部调用属性和方法，这样代码的可读性比较高，因为它明确的指出了这个属性或方法的来源。
2. 同时在构造函数中也可以使用this关键字调用本类中的其它构造函数，但有几点需要注意：（表示构造方法名，在构造方法内部，常用来构造方法的相互调用）
· 构造函数调用其它构造函数，需要将this写在构造函数的第一行。
· 构造函数不可递归，防止死循环。
3. 一个类的构造函数分为无参和有参构造函数。通常做法是指定写好一个包含所有字段的构造函数，然后其它构造函数可以直接调用该函数，实现代码重用。
5，构造代码块，随着对象的创建而执行，每一个构造方法执行前，都会先执行构造代码块。
6，调试的时候，什么时候用F5,F6
F5:单步执行，
F6:跨函数（方法）执行，只返回结果，不查看方法内的每一步执行。
另外：如果不是方法的调用，F5，F6效果一样。
1575
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
