java学习二
方法的概述
-
方法也叫函数、是完成特定功能的代码块。简单的来说，一个方法就是一个功能、一个动作或一种行为
-
当一些代代码反复使用时，可以把他们提取出来，放到一个方法里，以方法的形式来使用这些代码
-
大大的提高代码的复用性
方法的格式
private static void say(int a){
System.out.println("这是方法的表达式"+a);
}
//求2个数字之和
private static int sum(int... u){
int sum= 0;
for (int i = 0; i < u.length; i++) {
sum+=u[i];
}
System.out.println(sum);
return sum;
}
方法的调用（和上面对应）
public static void main(String[] args) {
say(2);
sum(3, 4);
}
方法的定义和调用事项
-
方法没有返回值时，也要有返回值类型 void
- 方法必须定义在类中
- 方法之间是平级关系，不能嵌套
- 方法返回值类型为 void 时 ，可以不要return
- return 语句后的数据类型必须和返回值类型匹配
- return 之后不能再放置语句
方法的重载
-
在同一个类中的多个方法，他们的方法名相同，参数列表不同，这样的情况，成为方法重载，和返回值类型无关
//求2个数字之和
private static int sum(int... u){
int sum= 0;
for (int i = 0; i < u.length; i++) {
sum+=u[i];
}
System.out.println(sum);
return sum;
}
private static double sum(double... u){
int sum= 0;
for (int i = 0; i < u.length; i++) {
sum+=u[i];
}
System.out.println(sum);
return sum;
}
数组的概念
-
数组是用来存储同一种数据类型多个元素的容器
-
数据类型：可以是基本类型，也可以是引用类型
-
数组长度定下之后，不能修改
数组的定义和访问
int[] i = new int[8];
int[] q ={1,2,3};
int[] arr =new int[]{88,4,4};
数组的索引
-
通过数组的索引访问数组的元素（从0开始访问）
int[] arr =new int[]{88,4,4};
System.out.println(arr[2]);
数组的赋值和遍历
public static void main(String[] args) {
int[][] arr = new int[4][5];
for (int i = 1; i < 4; i++) {
for (int j = 1; j < 5; j++) {
arr[i][j] = i*j;
}
}
for (int i = 1; i <4 ; i++) {
for (int j = 1; j < 5; j++) {
System.out.println(arr[i][j]);
}
System.out.println();
}
}
数组的存储图解
数组异常
-
数组下标越界 ArrayIndexOutOfBoundsException
-
空指针 NullPointerException
面向对象
面向对象的概述
-
面向对象的思想特点
-
是一种更符合人们思考习惯的思想
-
把复杂的事情简单化
-
把人们从执行者变成指挥者
-
-
面向对象的程序开发 就是不断的找对象、使用对象、指挥对象做事情的过程 没有对象？创建一个
-
面向对象的思想特征
-
封装
-
继承
-
多态
-
类与对象
-
java中如何描述一个事物
java中通过“类”来描述事物，类主要由属性和行为构成
-
类的概述
是一系列具有相同属性和行为的事物的统称
-
抽象
把一系列相关事物共同的属性和行为提取出来的过程
-
什么是对象 某一类事物的具体存在
-
事物的属性：在类中叫成员变量
-
事物的行为
-
-
安全、提高复用性
public static void main(String[] args) {
String arr = "1,2,2,3,4";
String[] split = arr.split(",");
for (int i = 0; i < split.length; i++) {
System.out.print(split[i]+" ");
}
}
你不需要知道split()方法是怎么写的，你只要知道它是根据“，”分割字符串即可。
构造器
public class Student {
private String name;
private int age;
/**
* 构造器 名称和类相同（必须）
* 没有返回值类型
* 没有返回值（但是可以写return）
*/
//有参构造
public Student(String name, int age) {
this.name = name;
this.age = age;
}
//无参构造
public Student() {
}
public void say() {
System.out.println(this.name + "今年" + this.age + "岁");
}
public static void main(String[] args) {
Student student = new Student("小明", 10);
student.say();
}
继承
public class Animal {
private String name;
private String master;
private int age;
public Animal() {
}
public Animal(String name, String master, int age) {
this.name = name;
this.master = master;
this.age = age;
}
public void say(){
System.out.println(this.master+"拥有一只"+name+",今年"+age+"岁");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getMaster() {
return master;
}
public void setMaster(String master) {
this.master = master;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class Dog extends Animal {
public Dog() {
}
public Dog(String name, String master, int age) {
super(name, master, age);
}
}
public class Test {
public static void main(String[] args) {
Dog dog = new Dog("狗","小明",10);
dog.say();
}
}
输出
小明拥有一只狗,今年10岁
多态
父类
//父类 动物
public class Animal {
private String name ="动物";
public void eat(){
System.out.println("吃什么");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
子类
public class Dog extends Animal{
public String name ="狗";
测试类
public static void main(String[] args) {
Animal animal = new Dog();
animal.eat();
Dog dog = (Dog) animal;
dog.watch();
if(animal instanceof Dog){
System.out.println("多态实现");
}
}
结果
动物吃骨头
看家
多态实现
Process finished with exit code 0
多态小结
-
多态调用方法是 编译在左 运行在右
-
多态调用成员变量时 编译在左 运行在左
抽象类
-
抽象类和抽象方法必须用abstract关键字修饰
-
抽象方法不能实例化
-
抽象类的子类
-
如果是普通类，则必须重写所有的抽象方法
-
如果是抽象类，则不用重写抽象方法
-
-
抽象类的成员特点
-
可以有普通的成员变量，也可以有成员变量
-
可以有抽象方法，也可以有非抽象方法
-
package cn.hxz.FinalPack;
//员工类 （父类）
public class Employee {
/**
* final这个单词是“最终”的意思，在java中是一个关键字，可以用来修饰类、成员变量、引用变量、成员方法
* 修饰类：不能被继承，但是可以继承其他的类
* 修饰的方法：不能被重写
* 修饰的变量：是一个常量，值只能设置一次
* 修饰的引用类型，是地址不能改变，但是属性值可以发生改变
*/
final int AGE = 10;
String name;
final void say(){
System.out.println("测试方法");
}
}
// 子类
class Coder extends Employee{
public static void main(String[] args) {
Employee e=new Coder();
// e.AGE = 20;报错 是一个常量，值只能设置一次
// @Override
// void say(){
// System.out.println("测试方法");
// } 报错 不能被重写
final Employee e1= new Employee();
// e1 = new Employee(); 报错 修饰的引用类型，是地址不能改变
e1.name = "10"; //修饰的引用类型 属性值可以发生改变
}
}
接口
public interface Demo4 {
/**
* 接口不能实例化对象，通过多态的方式实例化对象
* 接口的子类可以是抽象类，也可以是普通类
* 接口与接口之间的关系
* 继承关系，可以多继承
* 继承和实现的区别
* 继承体现的是“is a”的关系，父类中定义共性内容
* 接口实现体现的是“like a”的关系，接口中定义扩展功能
* 继承关系，只能单继承，不能多继承，但是可以多层继承
* 接口实现关系，可以单实现，也可以多实现
*
*
* 接口中没有成员变量，只有公有的，静态的常量
* public static final NUM= 常量值
* 接口中没有构造方法
*/
String NUM = "10";
//普通的方法
public abstract void say();
//静态方法
public static void say01(){
System.out.println("JDK8之后的特性");
}
// 非静态方法
public default void say02(){
System.out.println("JDK8之后的特性");
}
//JDK9之后的特性
private void say03(){
System.out.println("JDK9之后的特性");
}
}
