标签：java name void 基础 接口 class 面向对象 println public
1 面向对象之类与对象
# 类：
是抽象的概念，笼统的，不具体的 人类 狗类 鸟类
# 对象：
对象又叫实体,类的具体表现
人类中：厨师， 学生，老师
狗类：小狗1号，小黑狗
# 每个人对象都会有：姓名，性别，年龄，不同对象，属性又不一样
# 每个人的对象都会有方法：说话，走路
1.1 类的定义规范
// []内可以省略，|表示或单两个关键字不能同时出现
// public :表示类是公开的
// abstract:抽象类
// final :这个类不能被继承
// public abstract class Foo extends Animal implements 接口{}
[public] [abstract|final] class 类名class_name [extends 继承的类名] [implements 实现的接口名] {
// 定义成员属性--->属于对象
属性类型1 属性名1; // String name;
属性类型2 属性名2; // int age;
// 定义静态属性（类属性）--》属于类的
// 定义成员方法--》属于对象
public int add(int a,int b){
return a+b;
}
// 定义静态方法（类方法）---》属于类的
public static void speak(){
System.out.println("说话");
}
}
1.2 java类中的属性
// 语法
[public|protected|private] [static][final] <变量类型> <变量名>
// 解释
public protected private ：用于表示成员变量的访问权限
static ：表示该成员变量为类变量，也称为静态变量
final ：表示将该成员变量声明为常量，其值无法更改
变量类型 ：表示变量的类型
变量名：表示变量名称
public class Person{
public String name; // 属于对象的属性
final int sex =0; // 常量，其值无法更改
private int age; // 私有属性 age ，以后再类外部，取不到这个值的，用不了
static String shcool="清华"; // 类属性
}
1.3 创建一个类实例化得到对象
public class Demo01 {
public static void main(String[] args) {
// 1 类定义完了，要实例化得到对象
Person p=new Person();
// 2 使用对象的name属性
p.name="justin";
p.age=19;
System.out.println(p.name);
// 3 使用private修饰的属性,必须使用类中提供的方法来操作属性
p.setSex(true);
p.getSex();
// 4 使用对象方法
p.Speak();
}
}
class Person{
// 属性
public String name;
public int age;
private boolean sex; // true 是男，false是女
public boolean getSex(){
return this.sex;
}
public void setSex(boolean sex){
this.sex=sex;
}
// 方法
public void Speak(){
System.out.println("人说话");
}
}
1.4 成员方法（类中定义的方法）
// 类中的方法：定义格式如下
[public|private|protected] [abstract] [static|final] <void|return_type><方法名>([参数]) {
// 方法体
}
// 解释
public private protected ：表示成员方法的访问权限
abstract ：表示限定该成员方法为抽象方法。抽象方法不提供具体的实现，并且所属类型必须为抽象类
static ：表示限定该成员方法为静态方法(类的方法)
final ：表示限定该成员方法不能被重写或重载
<void|return_type>：返回值是空或某个类型
1.5 构造方法
// 特殊：构造方法跟类同名，没有返回值，不需要void关键字，可以有多个，表示多种构造方法
// 等同于python中的 __init__ ,不能写多个
public class Demo02 {
public static void main(String[] args) {
// 1 构造方法
Foo f = new Foo(); // 触发了无参构造，不需要写任何参数，如果不写构造方法，默认有个无参构造
Foo f1 = new Foo("justin", 19); // 触发了有参构造
Foo f2 = new Foo("justin"); // 触发了只有一个参数的有参构造
System.out.println(f.name); //null
System.out.println(f1.name); // justin
}
}
class Foo {
public String name;
public int age;
public Foo() { // 无参构造方法
}
public Foo(String name, int age) { // 有参构造方法
// 把传入的参数，赋值给对象的属性
// this.name取到的是对象的name，不同对象不一样，指的是上面定义的name public String name;
// name 是传入的参数
this.name = name;
this.age = age;
}
public Foo(String name) { // 有参构造方法
this.name=name;
}
}
1.6 this关键字
// 上面讲构造方法时，用了this关键字，this关键字是什么意思呢？
// this 只能用在类的内部的方法中（除了static修饰的方法）,对象方法---》代指当前实力对象--》等同于python中的self
public class Demo02 {
public static void main(String[] args) {
Foo f2 = new Foo("彭于晏"); // 触发了只有一个参数的有参构造
f2.speak();
}
}
class Foo {
public String name;
public Foo(String name) { // 有参构造方法
this.name=name;
}
public void speak(){
// 不同对象，打出来名字不一样
System.out.println("名字是：");
System.out.println(this.name);
System.out.println("在说话");
}
// 修改名字方法
public void changName(String name){
// 修改当前对象的name 哪个对象调用，this就是哪个对象
this.name=name;
}
}
1.7 访问控制修饰符
// 类只有两种
public
不写(default)
// 类中的变量，方法 都可以用以下几个关键字修饰
public
不写(默认，default，friendly)
protected
private
| 访问范围 |
private |
friendly(默认) |
protected |
public |
| 同一个类 |
可访问 |
可访问 |
可访问 |
可访问 |
| 同一包中的其他类 |
不可访问 |
可访问 |
可访问 |
可访问 |
| 不同包中的子类 |
不可访问 |
不可访问 |
可访问 |
可访问 |
| 不同包中的非子类 |
不可访问 |
不可访问 |
不可访问 |
可访问 |
1.8 静态变量和静态方法
// 类中属性或方法，只要被static修饰了，它就是类的方法或属性
public class Demo03 {
public static void main(String[] args) {
Aoo a =new Aoo();
a.speak();
//Aoo.speak(); //类调用不了
System.out.println(Aoo.getSchool());; // 类调用静态方法
System.out.println(a.getSchool());; // 对象调用静态方法
//Aoo.school="北大";
a.school="复旦";
System.out.println(Aoo.getSchool());; // 类调用静态方法
System.out.println(a.getSchool());; // 对象调用静态方法
}
}
class Aoo{
//属性
public String name; // 给对象的
public static String school="清华"; // 给类的
// 方法
public void speak(){ // 给对象的
System.out.println("说话");
}
public static String getSchool(){ // 是类的,类中没有this属性
return school;
}
}
2 面向对象之继承
2.1 继承格式
// 在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的，一般形式如下：
// Java中的继承，只支持单继承，不支持多继承，但支持实现多个接口
// python 支持多继承
class 父类 {
}
class 子类 extends 父类 {
}
class 子子类 extends 子类 {
}
public class Demo04 {
public static void main(String[] args) {
// 继承的基本使用
Coo c =new Coo();
c.run();
}
}
class Boo{
public void run(){
System.out.println("走路");
}
}
class Coo extends Boo{
}
2.2 构造方法
// 1 子类如果没写构造方法，默认使用父类无参构造
// 2 子类如果没写构造方法,不会自动使用父类的有参构造
public class Demo05 {
public static void main(String[] args) {
// 继承关系下的构造函数
Eoo e=new Eoo(); // 会使用父类的无参构造
System.out.println(e.name);
}
}
class Doo{
public String name;
// public Doo(){
// this.name="默认值";
// }
public Doo(String name){
this.name=name;
}
}
class Eoo extends Doo{
// 没有构造函数
}
2.3 super和this关键字
// this 代指当前对象
// super 代指父类对象
super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类
this关键字：指向自己的引用
public class Demo06 {
public static void main(String[] args) {
Hoo h= new Hoo();
h.zzz();
}
}
class Goo{
public void xx(){
System.out.println("xx");
}
}
class Hoo extends Goo{
public void zzz(){
// super.xx(); // 调用父类中的xx
this.xx(); // 调用自己的xx
}
public void xx(){
System.out.println("asdfasdfasdfasdf");
}
}
3 重写和重载
// 1 重写(Override)是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写
// 2 重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同
被重载的方法必须改变参数列表(参数个数或类型不一样)
public class Demo07 {
public static void main(String[] args) {
}
}
class Xoo {
public void Speak() {
System.out.println("xoo的speak");
}
}
class Yoo extends Xoo {
@Override
public void Speak() { // 重写
System.out.println("Yoo的speak");
}
public void run(){
System.out.println("跑步");
}
public void run(String name){ // 对run进行重载
System.out.println("跑步");
}
}
4 面向对象之接口
// ********************接口解释***************
1 接口（Interface），是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过实现接口的方法，从而来实现接口
2 接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
3 接口无法被实例化，但是可以被实现
一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。
4 接口与类相似点：
一个接口可以有多个方法
接口文件保存在 .java 结尾的文件中，文件名使用接口名
5 接口与类的区别：
接口不能用于实例化对象
接口没有构造方法
接口中所有的方法必须是抽象方法
接口不能包含成员变量，除了 static 和 final 变量
接口不是被类继承了，而是要被类实现
接口支持多继承
4.1 接口声明
[可见度] interface 接口名称 [extends 其他的接口名] {
// 声明变量 基本不会见
// 抽象方法
}
// 定义接口--->规范子类的行为
interface Duck{
// 属性--》一般不用
// 方法--》抽象方法---》没有具体实现
public void Speak(); // 不能有具体实现
public void run();
}
4.2 接口继承
//1 接口继承接口，可以多继承
// 定义接口--->规范子类的行为
interface Duck{
// 属性--》一般不用
// 方法--》抽象方法---》没有具体实现
public void Speak(); // 不能有具体实现
public void run();
}
interface PDuck{
public void Eat();
}
// 写一个接口，继承上面的接口
interface TDuck extends Duck,PDuck{
public void Fly();
}
4.3 接口实现
// 接口中定义了很多 方法，没有具体实现---》类实现接口---》把所有接口中的方法具体实现完
// 定义接口--->规范子类的行为
interface Duck {
// 属性--》一般不用
// 方法--》抽象方法---》没有具体实现
public void Speak(); // 不能有具体实现
public void run();
}
interface PDuck {
public void Eat();
}
// 写一个接口，继承上面的接口
interface TDuck extends Duck, PDuck {
public void Fly();
public void run(String name);
}
// 接口的实现，使用implements关键字，可以实现多个接口
// 实现接口，类中必须重写接口中所有方法，否则就报错
// 实现多个接口，如果有重复的，只需要实现一个即可
class Woo implements Duck,TDuck {
@Override
public void Speak() {
System.out.println("speak具体实现");
}
public void Speak(String name) {
System.out.println("speak具体实现");
}
@Override
public void run() {
System.out.println("run具体实现");
}
@Override
public void Eat() {
}
@Override
public void Fly() {
}
@Override
public void run(String name) {
}
}
5 面向对象之抽象类
public class Demo09 {
public static void main(String[] args) {
Cat c =new Cat();
c.run();
c.Speak();
}
}
abstract class Animal{
// 抽象类中，既可以有抽象方法
public abstract void Speak();
// 又可以有非抽象方法，有具体实现
public void run(){
System.out.println("小跑");
}
}
class Cat extends Animal{
// 继承了抽象类，必须实现抽象类中的抽象方法
@Override
public void Speak() {
System.out.println("说胡话");
}
}
// 抽象类和接口异同点
// 1 接口中的方法必须都是抽象方法，没有具体实现
// 2 抽象类可以有抽象方法，也可以有非抽象方法
// 3 接口可以实现多个，但是类只能继承一个
6 面向对象封装
// 1 把属性或方法放到类内部，以后使用对象调用属性或方法--》称之为封装
// 2 封装之隐藏属性
python 使用 __开头 属性或方法就是隐藏
java private 修饰，只能在类内部使用，外部不能使用
// 3 既然隐藏了属性，就要对外暴漏能够修改属性的方法
set变量名
get变量名
public class Demo10 {
public static void main(String[] args) {
Dog d = new Dog();
d.name = "小野狗";
System.out.println(d.name);
//d.age=10; // 隐藏属性
d.setAge(999);
System.out.println(d.getAge());
}
}
class Dog {
public String name;
private int age;
public int getAge() {
return age;
}
public void setAge(int age) {
if (age > 100) {
System.out.println("不允许大于100");
} else {
this.age = age;
}
}
}
7 多态
// ***********多态解释**********************
// 多态是同一类事物[实例，对象]多种形态，从而调用同一类[实例，对象]方法时，表现出不同
动物： 狗 猫 人
都可以走路： 动物对象.走路()
狗.走路()
// **********************多态存在的三个必要条件**********************
（1）编写具有继承关系的父类和子类
（2）子类重写父类方法
（3）使用父类的引用指向子类的对象
public class Demo11 {
public static void main(String[] args) {
Dog1 dog = new Dog1();
Cat1 cat = new Cat1();
// dog和cat其实是同一类，Animal1这一类
Animal1 a = dog; // dog 属于Animal这一类，可以把dog的对象赋值给Animal
a = cat; // cat 属于Animal1这一类，可以把cat的对象赋值给Animal1
// animalRun(dog);
// animalRun(cat);
animalRun(a);
}
// public void animalRun(Dog1 dog){
// dog.run();
// }
// public void animalRun(Cat1 cat){
// cat.run();
// }
public static void animalRun(Animal1 obj){
obj.run();
}
}
class Animal1 {
public void run() {
System.out.println("AAA的run");
}
}
class Dog1 extends Animal1 {
public void run() {
System.out.println("Dog1的run");
}
}
class Cat1 extends Animal1 {
public void run() {
System.out.println("Cat1的run");
}
}
8 枚举类型
// Java 枚举是一个特殊的类，一般表示一组常量，
一年的 4 个季节
一年的 12 个月份
性别有男，女，未知
public class Demo12 {
public static void main(String[] args) {
System.out.println(Sex.Female);
System.out.println(Sex.UnKnown);
System.out.println(Sex.Male);
}
}
// 定义一个枚举
enum Sex {
Male,
Female,
UnKnown
}
9 包
// 为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。
- 同一个包下，不能命名出同名的类
-不同包下，可以有同名的类
// 包的作用
1、把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用
2、同文件夹一样，包采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
3、包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。
import com.justin.aaa.Animal;
public class Demo13 {
public static void main(String[] args) {
Animal a =new Animal();
a.name="xxx";
a.SpeakName();
// 使用bbb下的Animal
com.justin.bbb.Animal b = new com.justin.bbb.Animal();
b.run();
}
}
标签：java,
name,
void,
基础,
接口,
class,
面向对象,
println,
public
From： https://www.cnblogs.com/simon1993/p/17743644.html