韩顺平老师java视频课程笔记1-13课

JA V A学习记录

第一讲

//pulic:表示这个类是公共的，一个java文件中只能有一个public类//class :表示这是一个类

//Hello:类名（公共类的类名必须和文件名一致）

public class Hello

{

//一个主函数，相当于是程序的入口

public static void main (String args[])

{

/* 多行注释*/

//System.out.println("hello");

int a=10;// 定义一个变量，变量名位a,它的值为10

// int为4个字节，long为8个字节int b=20;

int result=a+b

//输出结果

system.out.println("结果是"+result)

}

}

第二讲JA V A基本数据类型

四大类型

整数类型

小数（浮点）类型

基本数据类型

布尔类型

字符类型

1.整数类型

整数类型表示一个整数，常用的整数类型有：

byte, short, int, long

范围：

byte 一个字节-128 – 127

short 两个字节-32768 - 32767

int 四个字节-2147483648 – 2147483647

long 八个字节

一个字节= 八个byte

例：一个byte

0 0 0 0 0 0 0 1 最高位为符号位0表示正数，1表示负数

1 1 1 1 1 1 1 1 – 0 1 1 1 1 1 1 1

2.小数（浮点）类型

常用类型有float, double

3.布尔类型

可以表示：真或者假，类型是boolean

4.字符类型

表示单个字符，字符类型是char，chai是两个字节，可以存放汉字。

多个字符称为字符串，在java中用String表示，String属于类。

.

在java中，对char进行运算的时候，直接当做ascii码对应的整数对待。（汉字则是unic码）

定义变量int a

初始化变量int a = 45

给变量赋值int a ; a =45

基本数据类型转换

int a = 1.2 错误会损失精度

double a = 4 正确数据类型可以自动从低精度向高精度转换。

byte

在java中的小数默认是double,于是需要float a = 3.4f

计算过程中的转换：

当一个整数和一个double进行运算时，会自动向高精度转换.

第三讲运算符流控制

1.+ 加

2.- 减

3.* 乘

4./ 除

5.% 取模即取两个数相除的余数。如5%3=2

pulic class demo1

{

Public static void main (String [ ]args )

{

Int a=2

Int b=4

If (b%a==0) // ==表示判断是否等于0

{

System.out.println(―可以整除‖)；

}else{

System.out.println(―不能整除‖)；

}

}

}

++ 自加

-- 自减

1.int b=++a

(

a=a+1

b=a

)

2.int b=a++

(

b=a

a=a+1

)

算数运算符

1.+= 左加

2.-= 左减

3./= 左除

4.%= 左取模

如：

int a =90

a+=90; => a=a+90

float b=89.7

b+=a => b=b+a

例：a-=34;b%=a

即：a=a+34; b=b%a

关系运算符

1.== 等于

2. >大于

3.<小于

4.>= 大于等于

5.<=小于等于

6.!=不等于

逻辑运算符

1.&& 与

2.|| 或

3.！非

例：int a= 90; int b=90;

if(a==b||a>8){System.out.print(―ok1‖);}

b--;

if (a>b && a>45){System.out.println(―ok2‖);}

if(!(a<=b)){System.out.println(―ok3‖);}

java基本语法

一.顺序控制，让程序可以顺序执行。

二.分支控制，让程序有选择的执行。

1.单分支

if(条件表达式){

语句

}

2.双分支

if(条件表达式){

语句

}else{

语句

}

3.多分支

if(条件表达式){

语句

}else if(条件表达式){

语句

} else if(条件表达式){

语句

} else{

语句

}

三.流控制

swich(条件表达){

case 常量1：

语句1；

break;

case 常量2：

语句2；

break;

…….

default:

语句；

break;

}

1.条件表达式数据类型，应和case后的常量类型一致。

2.switch中可用的数据类型主要有byte,short,int,char,enum等。enum枚举

三.循环控制

1.for循环。

例：for(int i=0;i<10;i++)

{

System.out.println(―你好‖)

}

2.while循环。

例：int i=0;

while(i<10);

{

System.out.println(―你好‖);

i++

}

先判断，再执行。

3.do while循环。

例：int i=0

do{

System.out.print(―你好‖);

i++;

}while(i<0);

先执行，再判断，不论条件如何都会执行一次。

经典案例：金字塔打印：

int lay=4;

//表示有多少层

for (int i=1;i<=lay;i++)

{

//找出空格规律

//1=>3 2=>2 3=>1 4=>0

for(int k=1;k<=lay-i;k++)

{

System.out.print(―‖);

}

//打印*

//1=>1 2=>3 3=>5 4=>7

for (int j=1;j<=(i-1)*2+1;J++)

{

System.out.print(―*‖);

}

//打出换行

System.out.print( );

}

镂空的金字塔：

int lay=4;

//表示有多少层

for (int i=1;i<=lay;i++)

{

//找出空格规律

//1=>3 2=>2 3=>1 4=>0

for(int k=1;k<=lay-I;k++)

{

System.out.print(―‖);

}

//打印*

//1=>1 2=>3 3=>5 4=>7

for (int j=1;j<=(i-1)*2+1;J++)

//判断该层是否是顶层或底层.

if(i==1||i==lay){

System.out.print(―*‖);

}

else

{

//如果是第一个*

if(j==1||j==(i-1)*2+1)

{

System.out.print(―*‖);

}

else{

System.out.print(―‖);

}

}

{

System.out.print(―*‖);

}

//打出换行

System.out.print( );

}

课后题，镂空菱形。

Java面向对象编程-类与对象、构造方法

类是抽象的，概念的，代表一类事物，比如人类，猫类

对象是具体的，实际的，代表一个具体事物。

类的对象是模板，对象是类的一个个体，实例。

类----如何定义一个类。

package 包名；

class 类名extends 父类implements

接口名{

成员变量；

构造方法；

成员方法；

}

成员变量--是类的一个组成部分，一般是基本数据类型也可以是引用类型（指向另外一个类）。比如我前面定义猫类的int age 就是成员变量。（类名首字母为大写）

对象—如何创建对象

创建一个对象有两种方法

1.先声明再创建

对象声明：类名对象名

对象创建：对象名=new 类名（）

2.一步到位法

类名对象名=new 类名（）

对象---如何访问（使用）对象的成员变量

对象名.变量名；

如：

Person a=new Person();

a.age=10;

https://www.360docs.net/doc/689762637.html,n=‖小明‖；

Person b;

b=a;

System.out.print(b.age);

//b,a指向内存同一块空间，修改b值也将导致a值变化。

类—类成员方法（成员函数）定义

public 返回数据类型方法名（参数列表）

{

语句；// 方法（函数）主体

}

1.参数列表：表示成员函数输入

2.数据类型（返回类型）：表示成员函数输出。

3.函数主体：表示为了实现某一功能代码块

（方法名首字母为小写）如何定名字1.驼峰法myCry 2.下划线法my_cry

类成员的方法—声明：

public int test(int a);// 方法声明

这句话的作用是声明该方法，声明的格式为：

访问修饰符数据类型函数名（参数列表）

return 表达式；

方法可以没有返回值。

类的构造方法

1方法名和类名相同2没有返回值

3在创建一个类的新对象时，系统会自动的调用该类的构造方法完成对新对象的初始化。

类的构造方法小结

1.构造方法名和类名相同。

2.构造方法没有返回值。

3.主要作用是完成对新对象的初始化

4.在创建新对象时，系统自动的调用该类的构造方法。

5.一个类可以有多个构造方法。

6.每个类都有一个默认的构造方法。

练习：编写一个成员函数，从键盘输入一个一个整数，打印出对应的乘法表

public公有的是java的访问修饰符！

看下访问修饰符

1.public（公有的）：可以被该类的和非该类的任何成员访问。

2.private（私有的）：仅仅可以被该类的成员访问，任何非该类的成员一概不能访问。（主要是隐藏数据来保证数据的安全性）

3.protected（保护的）：仅仅可以被子类和类本身还有同一个包里的类访问。

//void是无返回值的意思。

比方说public void walk()

{

System.out.print("你好!");

}

如果别的地方调用这个方法就会打印出你好！

再看这里:

public String walk() //注意这里的返回类型是String不是void了

{

System.out.print("你好!");

return "哈喽"; //注意这里这个return 如果不写就会报错！

}

原因就是因为上面的返回类型必须是String型。

如果写的是void意思就是不需要返回类型。所以就没必要写return 了。

如果方法上面写了某种返回类型就必须写return后面跟相应的类型值。

this代词

this 是属于一个对象的，而不是属于一个类的。

类变量

类变量是该类的所有对象共享的变量，任何一个该类的对象去访问他时，取到的都是相同的值，同样任何一个该类的对象去修改他时，修改的也是同一个变量。

如何定义一个类变量：static 数据类型变量名；

如何访问类变量：类名．类变量名或者对象名．类变量名

类方法：类方法是属于所有对象实例的，其形式如下：

访问修饰符static 数据返回类型方法名( ) { }

注意：类方法中布能访问非静态变量（类变量）。

使用：类名．类方法名或者对象名．类方法名

public class demo_1

{

/*static int i=1;

static

{

//该静态区域块，只被执行一次。

i++;

}

public demo_1()

{

i++;

}*/

public static void main (String []args)

{

demo_1 t1=new demo_1();

System.out.println(t1.i);

demo_1 t2=new demo_1();

System.out.println(t2.i);

stu stu1=new stu(29,"aa",340);

stu stu1=new stu(39,"bb",360);

}

}

//学生

class Stu

{

int age;

String name;

int fee;

static int totalFee;

public Stu(int age,String name,int fee)

{

this.age=age;

https://www.360docs.net/doc/689762637.html,=name;

totalFee+=fee;

}

//返回总学费｛这是一个类方法（静态方法）｝

//java中规则：类变量原则上用类方法去访问

public static int getTotalFee()

{

return totalFee;

}

}

类变量小结

１．什么时候需要用类变量

案例：定义学生类，统计学生共交多少钱？

用类变量，属于公共的属性

２．类变量于实例变量区别

加上static称为类变量和静态变量，否则称为实例变量

类变量是与类相关的，公共的属性

实例变量属于每个对象个体的属性

类变量可以通过类名．类变量名直接访问。

封装－什么是封装

封装就是把抽象出得数据和对数据的操作封装在一起，数据被保护在内部，程序的其他部分只有通过被授权的操作（成员方法），才能对数据进行操作。

封装－访问控制修饰符

1.公开级别，用public修饰，对外公开

2.受保护级别：用protected修饰，对子类和同义个包中的类公开

3.默认级别：没有修饰符号，向同义个包得类公开。

4.私有级别：用private修饰，只有类本身可以访问，不对外公开。

包－三大作用

１．区分相同名字的类

２．当类很多时，可以很好的管理类

３．控制方位范围

打包命令：

package com.shunping;

包－命令规范

小写字母比如package com.shunping

包－常用的包

一个包下，包含很多的类，java中常用的包有：

https://www.360docs.net/doc/689762637.html,ng.*包自动引入java.util.*工具包

https://www.360docs.net/doc/689762637.html,.*网络开发包java.awt.*包窗口工具包

包－如何引入一个包

第十讲

继承---解决之道

继承可以解决代码复用，让我们的变成可以更加靠近人类思维，当多个类存在相同的属性（变量）和方法时，可以从这些类冲抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extengs语句来声明继承父类：

class 子类extends父类

这样，子类就会自动拥有父类定义的某些属性和方法。

继承―深入讨论

父类的public,protected,默认修饰符的属性和方和被子类继承了，private修饰符的属性和方法不能被子类继承。

子类最多只能继承一个父类。

pa ckage com.shunping;

//说明继承的必要性

public class Dmeo1 {

public static void main(String[] args) {

// TODO Auto-generated method stub

Pupil p1=new Pupil();

p1.printName();

}

}

//继承

//将学生的共有属性提出，做一个父类。

//小学生类

class Stu //父类

{

public int age;

public String name;

private float fee;

public void printName()

{

System.out.println("学生是："+https://www.360docs.net/doc/689762637.html,);

}

}

class Pupil extends Stu

{

//缴费

public void pay(float fee)

{

this.fee=fee;

}

}

//中学生类

class MiddleStu extends Stu{

//缴费

public void pay(float fee)

{

this.fee=fee*0.8f;

}

}

//大学生类

class ColStu extends Stu{

//缴费

public void pay(float fee)

{

this.fee=fee*0.1f;

}

}

方法重载（overload）:

例请编写一个类（Abc）,编写方法可以接受两个整数，返回两个数中较大的数，请编程实现。package demo2;

public class Abc

{

public void main (String []args)

{

Abc1 a1=new Abc1();

System.out.println(a1.getMax(12,4));

System.out.println(a1.getMax(12.5f,4.5f));

}

}

class Abc1 {

//返回较大整数

public int getMax(int i,int j) {

if (i>j)

{

return i;

}else

{

return j;

}

}

public float getMax(float a,float b){

if (a>b)

{

return a;

}else

{

return b;

}

}

}

简单的说：方法重载就是类的同一种功能的多种实现方式，到底采用哪种方式，取决于调用者给出得参数。

注意事项：

１．方法名相同

２．方法的参数类型，个数，顺序至少有一项不同

３．方法的返回类型可以不同

４．方法的修饰符可以不同

只是访问修饰符或者返回类型不一样不能构成重载。

方法覆盖（override）

//主函数及调用略。

class Animal

{

int age;

public void cry()

{

System.out.print("不知道怎么叫");

}

}

class Cat extends Animal

{

//覆盖父类

public void cry()

{

System.out.print("喵喵叫");

}

}

第十一讲

方法覆盖（override）-注意事项

１子类的方法和返回类型，参数，方法名称，要喝父类方法的返回类型，参数，方法名称完全一样，否则编译出错。

２子类方法不能缩小父类方法的访问权限。

第十二讲多态

多态是指一个引用（类型）在不同情况下的多种状态。也可以这样理解多态是指通过指向父类的指针，来调用在不同子类中实现的方法。

注意事项

java允许父类的引用变量引用他的子类的实例（对象）

Animal animal = new Cat();